[browser][wasm] Make response streaming opt-out (#111680)

Co-authored-by: campersau <buchholz.bastian@googlemail.com>
Co-authored-by: pavelsavara <pavel.savara@gmail.com>

Author: campersau

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

@@ -244,11 +244,6 @@ await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
                     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 () =>
                     {

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

@@ -1005,12 +1005,9 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                 var request = new HttpRequestMessage(HttpMethod.Get, uri) { Version = UseVersion };
                 if (PlatformDetection.IsBrowser)
                 {
-                    if (enableWasmStreaming)
-                    {
 #if !NETFRAMEWORK
-                        request.Options.Set(new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse"), true);
+                    request.Options.Set(new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse"), enableWasmStreaming);
 #endif
-                    }
                 }
 
                 using (var client = new HttpMessageInvoker(CreateHttpClientHandler()))
@@ -1239,7 +1236,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                         // Boolean properties returning correct values
                         Assert.True(responseStream.CanRead);
                         Assert.False(responseStream.CanWrite);
-                        Assert.Equal(PlatformDetection.IsBrowser, responseStream.CanSeek);
+                        Assert.False(responseStream.CanSeek);
 
                         // Not supported operations
                         Assert.Throws<NotSupportedException>(() => responseStream.BeginWrite(new byte[1], 0, 1, null, null));
@@ -1270,11 +1267,14 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                         Assert.Throws<ArgumentOutOfRangeException>(() => { responseStream.CopyToAsync(Stream.Null, -1, default); });
                         Assert.Throws<NotSupportedException>(() => { responseStream.CopyToAsync(nonWritableStream, 100, default); });
                         Assert.Throws<ObjectDisposedException>(() => { responseStream.CopyToAsync(disposedStream, 100, default); });
-                        Assert.Throws<ArgumentNullException>(() => responseStream.Read(null, 0, 100));
-                        Assert.Throws<ArgumentOutOfRangeException>(() => responseStream.Read(new byte[1], -1, 1));
-                        Assert.ThrowsAny<ArgumentException>(() => responseStream.Read(new byte[1], 2, 1));
-                        Assert.Throws<ArgumentOutOfRangeException>(() => responseStream.Read(new byte[1], 0, -1));
-                        Assert.ThrowsAny<ArgumentException>(() => responseStream.Read(new byte[1], 0, 2));
+                        if (PlatformDetection.IsNotBrowser)
+                        {
+                            Assert.Throws<ArgumentNullException>(() => responseStream.Read(null, 0, 100));
+                            Assert.Throws<ArgumentOutOfRangeException>(() => responseStream.Read(new byte[1], -1, 1));
+                            Assert.ThrowsAny<ArgumentException>(() => responseStream.Read(new byte[1], 2, 1));
+                            Assert.Throws<ArgumentOutOfRangeException>(() => responseStream.Read(new byte[1], 0, -1));
+                            Assert.ThrowsAny<ArgumentException>(() => responseStream.Read(new byte[1], 0, 2));
+                        }
                         Assert.Throws<ArgumentNullException>(() => responseStream.BeginRead(null, 0, 100, null, null));
                         Assert.Throws<ArgumentOutOfRangeException>(() => responseStream.BeginRead(new byte[1], -1, 1, null, null));
                         Assert.ThrowsAny<ArgumentException>(() => responseStream.BeginRead(new byte[1], 2, 1, null, null));
@@ -1284,29 +1284,37 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                         Assert.Throws<ArgumentNullException>(() => { responseStream.CopyTo(null); });
                         Assert.Throws<ArgumentNullException>(() => { responseStream.CopyToAsync(null, 100, default); });
                         Assert.Throws<ArgumentNullException>(() => { responseStream.CopyToAsync(null, 100, default); });
-                        Assert.Throws<ArgumentNullException>(() => { responseStream.Read(null, 0, 100); });
                         Assert.Throws<ArgumentNullException>(() => { responseStream.ReadAsync(null, 0, 100, default); });
                         Assert.Throws<ArgumentNullException>(() => { responseStream.BeginRead(null, 0, 100, null, null); });
 
                         // Empty reads
                         var buffer = new byte[1];
-                        Assert.Equal(-1, responseStream.ReadByte());
-                        Assert.Equal(0, await Task.Factory.FromAsync(responseStream.BeginRead, responseStream.EndRead, buffer, 0, 1, null));
+                        if (PlatformDetection.IsNotBrowser)
+                        {
+                            Assert.Equal(-1, responseStream.ReadByte());
+                            Assert.Equal(0, await Task.Factory.FromAsync(responseStream.BeginRead, responseStream.EndRead, buffer, 0, 1, null));
+                        }
 #if !NETFRAMEWORK
                         Assert.Equal(0, await responseStream.ReadAsync(new Memory<byte>(buffer)));
 #endif
                         Assert.Equal(0, await responseStream.ReadAsync(buffer, 0, 1));
+                        if (PlatformDetection.IsNotBrowser)
+                        {
 #if !NETFRAMEWORK
-                        Assert.Equal(0, responseStream.Read(new Span<byte>(buffer)));
+                            Assert.Equal(0, responseStream.Read(new Span<byte>(buffer)));
 #endif
-                        Assert.Equal(0, responseStream.Read(buffer, 0, 1));
+                            Assert.Equal(0, responseStream.Read(buffer, 0, 1));
+                        }
 
                         // Empty copies
                         var ms = new MemoryStream();
                         await responseStream.CopyToAsync(ms);
                         Assert.Equal(0, ms.Length);
-                        responseStream.CopyTo(ms);
-                        Assert.Equal(0, ms.Length);
+                        if (PlatformDetection.IsNotBrowser)
+                        {
+                            responseStream.CopyTo(ms);
+                            Assert.Equal(0, ms.Length);
+                        }
                     }
                 }
             },
@@ -1322,9 +1330,6 @@ public async Task ReadAsStreamAsync_StreamingCancellation()
             await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             {
                 var request = new HttpRequestMessage(HttpMethod.Get, uri) { Version = UseVersion };
-#if !NETFRAMEWORK
-                request.Options.Set(new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse"), true);
-#endif
 
                 var cts = new CancellationTokenSource();
                 using (var client = new HttpMessageInvoker(CreateHttpClientHandler()))

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

@@ -25,6 +25,8 @@ public static IEnumerable<object[]> RemoteServersAndReadModes()
             {
                 for (int i = 0; i < 8; i++)
                 {
+                    if (PlatformDetection.IsBrowser && i is 0 or 2 or 4 or 5 or 6) continue; // ignore sync reads
+
                     yield return new object[] { remoteServer, i };
                 }
             }
@@ -176,10 +178,13 @@ public async Task GetStreamAsync_ReadZeroBytes_Success(Configuration.Http.Remote
             using (HttpClient client = CreateHttpClientForRemoteServer(remoteServer))
             using (Stream stream = await client.GetStreamAsync(remoteServer.EchoUri))
             {
-                Assert.Equal(0, stream.Read(new byte[1], 0, 0));
+                if (PlatformDetection.IsNotBrowser)
+                {
+                    Assert.Equal(0, stream.Read(new byte[1], 0, 0));
 #if !NETFRAMEWORK
-                Assert.Equal(0, stream.Read(new Span<byte>(new byte[1], 0, 0)));
+                    Assert.Equal(0, stream.Read(new Span<byte>(new byte[1], 0, 0)));
 #endif
+                }
                 Assert.Equal(0, await stream.ReadAsync(new byte[1], 0, 0));
             }
         }
@@ -200,7 +205,7 @@ await client.GetAsync(remoteServer.EchoUri, HttpCompletionOption.ResponseHeaders
                 cts.Cancel();
 
                 // Verify that the task completed.
-                Assert.True(((IAsyncResult)task).AsyncWaitHandle.WaitOne(new TimeSpan(0, 5, 0)));
+                Assert.Same(task, await Task.WhenAny(task, Task.Delay(TimeSpan.FromMinutes(5))));
                 Assert.True(task.IsCompleted, "Task was not yet completed");
 
                 // Verify that the task completed successfully or is canceled.
@@ -327,12 +332,10 @@ public async Task BrowserHttpHandler_StreamingResponseAbort(HttpMethod method, s
         public async Task BrowserHttpHandler_Streaming()
         {
             var WebAssemblyEnableStreamingRequestKey = new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingRequest");
-            var WebAssemblyEnableStreamingResponseKey = new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse");
 
             var req = new HttpRequestMessage(HttpMethod.Post, Configuration.Http.RemoteHttp2Server.BaseUri + "echobody.ashx");
 
             req.Options.Set(WebAssemblyEnableStreamingRequestKey, true);
-            req.Options.Set(WebAssemblyEnableStreamingResponseKey, true);
 
             byte[] body = new byte[1024 * 1024];
             Random.Shared.NextBytes(body);
@@ -578,16 +581,12 @@ public async Task BrowserHttpHandler_StreamingRequest_Http1Fails()
         }
 
         [OuterLoop]
-        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsChromium))]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsBrowser))]
         public async Task BrowserHttpHandler_StreamingResponseLarge()
         {
-            var WebAssemblyEnableStreamingResponseKey = new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse");
-
             var size = 1500 * 1024 * 1024;
             var req = new HttpRequestMessage(HttpMethod.Get, Configuration.Http.RemoteSecureHttp11Server.BaseUri + "large.ashx?size=" + size);
 
-            req.Options.Set(WebAssemblyEnableStreamingResponseKey, true);
-
             using (HttpClient client = CreateHttpClientForRemoteServer(Configuration.Http.RemoteSecureHttp11Server))
             // we need to switch off Response buffering of default ResponseContentRead option
             using (HttpResponseMessage response = await client.SendAsync(req, HttpCompletionOption.ResponseHeadersRead))
@@ -605,7 +604,7 @@ public async Task BrowserHttpHandler_StreamingResponseLarge()
                 int fetchedCount = 0;
                 do
                 {
-                    // with WebAssemblyEnableStreamingResponse option set, we will be using https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader/read
+                    // we will be using https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader/read
                     fetchedCount = await stream.ReadAsync(buffer, 0, buffer.Length);
                     totalCount += fetchedCount;
                 } while (fetchedCount != 0);

src/libraries/System.Net.Http/src/ILLink/ILLink.Substitutions.xml

@@ -4,4 +4,9 @@
       <method signature="System.Boolean IsGloballyEnabled()" body="stub" value="false" feature="System.Net.Http.EnableActivityPropagation" featurevalue="false" />
     </type>
   </assembly>
+  <assembly fullname="System.Net.Http" feature="System.Net.Http.WebAssemblyEnableStreamingResponse" featurevalue="false">
+    <type fullname="System.Net.Http.BrowserHttpController">
+      <method signature="System.Boolean get_FeatureEnableStreamingResponse()" body="stub" value="false" />
+    </type>
+  </assembly>
 </linker>

src/libraries/System.Net.Http/src/System/Net/Http/BrowserHttpHandler/BrowserHttpHandler.cs

@@ -9,6 +9,7 @@
 using System.Runtime.InteropServices.JavaScript;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Diagnostics.CodeAnalysis;
 
 namespace System.Net.Http
 {
@@ -134,6 +135,9 @@ internal sealed class BrowserHttpController : IDisposable
         private static readonly HttpRequestOptionsKey<bool> EnableStreamingResponse = new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse");
         private static readonly HttpRequestOptionsKey<IDictionary<string, object>> FetchOptions = new HttpRequestOptionsKey<IDictionary<string, object>>("WebAssemblyFetchOptions");
 
+        [FeatureSwitchDefinition("System.Net.Http.WasmEnableStreamingResponse")]
+        internal static bool FeatureEnableStreamingResponse { get; } = AppContextConfigHelper.GetBooleanConfig("System.Net.Http.WasmEnableStreamingResponse", "DOTNET_WASM_ENABLE_STREAMING_RESPONSE", defaultValue: true);
+
         internal readonly JSObject _jsController;
         private readonly CancellationTokenRegistration _abortRegistration;
         private readonly string[] _optionNames;
@@ -143,7 +147,7 @@ internal sealed class BrowserHttpController : IDisposable
         private readonly string uri;
         private readonly CancellationToken _cancellationToken;
         private readonly HttpRequestMessage _request;
-        private bool _isDisposed;
+        internal bool _isDisposed;
 
         public BrowserHttpController(HttpRequestMessage request, bool? allowAutoRedirect, CancellationToken cancellationToken)
         {
@@ -314,10 +318,14 @@ private HttpResponseMessage ConvertResponse()
                     responseMessage.SetReasonPhraseWithoutValidation(responseType);
                 }
 
-                bool streamingResponseEnabled = false;
-                if (BrowserHttpInterop.SupportsStreamingResponse())
+                bool streamingResponseEnabled = FeatureEnableStreamingResponse;
+                if (_request.Options.TryGetValue(EnableStreamingResponse, out var reqStreamingResponseEnabled))
+                {
+                    streamingResponseEnabled = reqStreamingResponseEnabled;
+                }
+                if (streamingResponseEnabled && !BrowserHttpInterop.SupportsStreamingResponse())
                 {
-                    _request.Options.TryGetValue(EnableStreamingResponse, out streamingResponseEnabled);
+                    throw new PlatformNotSupportedException("Streaming response is not supported in this browser.");
                 }
 
                 responseMessage.Content = streamingResponseEnabled
@@ -361,10 +369,10 @@ public void Dispose()
     internal sealed class BrowserHttpWriteStream : Stream
     {
         private readonly BrowserHttpController _controller; // we don't own it, we don't dispose it from here
+
         public BrowserHttpWriteStream(BrowserHttpController controller)
         {
             ArgumentNullException.ThrowIfNull(controller);
-
             _controller = controller;
         }
 
@@ -392,7 +400,7 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati
 
         public override bool CanRead => false;
         public override bool CanSeek => false;
-        public override bool CanWrite => true;
+        public override bool CanWrite => !_controller._isDisposed;
 
         protected override void Dispose(bool disposing)
         {
@@ -506,7 +514,7 @@ protected override void Dispose(bool disposing)
 
     internal sealed class BrowserHttpReadStream : Stream
     {
-        private BrowserHttpController _controller; // we own the object and have to dispose it
+        private readonly BrowserHttpController _controller; // we own the object and have to dispose it
 
         public BrowserHttpReadStream(BrowserHttpController controller)
         {
@@ -540,7 +548,7 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
             return ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();
         }
 
-        public override bool CanRead => true;
+        public override bool CanRead => !_controller._isDisposed;
         public override bool CanSeek => false;
         public override bool CanWrite => false;
 
@@ -582,4 +590,24 @@ public override void Write(byte[] buffer, int offset, int count)
         }
         #endregion
     }
+
+    internal static class AppContextConfigHelper
+    {
+        internal static bool GetBooleanConfig(string switchName, string envVariable, bool defaultValue = false)
+        {
+            string? str = Environment.GetEnvironmentVariable(envVariable);
+            if (str != null)
+            {
+                if (str == "1" || str.Equals("true", StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+                if (str == "0" || str.Equals("false", StringComparison.OrdinalIgnoreCase))
+                {
+                    return false;
+                }
+            }
+            return AppContext.TryGetSwitch(switchName, out bool value) ? value : defaultValue;
+        }
+    }
 }

src/libraries/System.Net.Http/src/System/Net/Http/BrowserHttpHandler/BrowserHttpInterop.cs

@@ -11,11 +11,26 @@ namespace System.Net.Http
 {
     internal static partial class BrowserHttpInterop
     {
+        private static bool? _SupportsStreamingRequest;
+        private static bool? _SupportsStreamingResponse;
+
+        public static bool SupportsStreamingRequest()
+        {
+            _SupportsStreamingRequest ??= SupportsStreamingRequestImpl();
+            return _SupportsStreamingRequest.Value;
+        }
+
+        public static bool SupportsStreamingResponse()
+        {
+            _SupportsStreamingResponse ??= SupportsStreamingResponseImpl();
+            return _SupportsStreamingResponse.Value;
+        }
+
         [JSImport("INTERNAL.http_wasm_supports_streaming_request")]
-        public static partial bool SupportsStreamingRequest();
+        public static partial bool SupportsStreamingRequestImpl();
 
         [JSImport("INTERNAL.http_wasm_supports_streaming_response")]
-        public static partial bool SupportsStreamingResponse();
+        public static partial bool SupportsStreamingResponseImpl();
 
         [JSImport("INTERNAL.http_wasm_create_controller")]
         public static partial JSObject CreateController();

src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System.Runtime.InteropServices.JavaScript.Tests.csproj

@@ -20,6 +20,7 @@
     <!-- This test library intentionally references inbox P2Ps as it needs the implementation, instead of the contract.
          Suppress the NU1511 warning in the whole project as putting it on a P2P doesn't work: https://github.com/NuGet/Home/issues/14121 -->
     <NoWarn>$(NoWarn);NU1511</NoWarn>
+    <WasmEnableStreamingResponse>false</WasmEnableStreamingResponse>
   </PropertyGroup>
 
   <!-- Make debugging easier -->

src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System/Runtime/InteropServices/JavaScript/HttpRequestMessageTest.cs

@@ -16,6 +16,8 @@ namespace System.Runtime.InteropServices.JavaScript.Http.Tests
 {
     public class HttpRequestMessageTest
     {
+        public static readonly string LocalHttpEcho = "http://" + Environment.GetEnvironmentVariable("DOTNET_TEST_HTTPHOST") + "/Echo.ashx";
+
         private readonly Version _expectedRequestMessageVersion = HttpVersion.Version11;
         private HttpRequestOptionsKey<bool> EnableStreamingResponse = new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse");
         private HttpRequestOptionsKey<IDictionary<string, object?>> FetchOptions = new HttpRequestOptionsKey<IDictionary<string, object?>>("WebAssemblyFetchOptions");
@@ -295,6 +297,31 @@ public void Properties_SetOptionsAndGetTheirValue_NotSet_EnableStreamingResponse
             Assert.False(streamingEnabledValue);
         }
 
+        [Fact]
+        public async Task HttpStreamingDisabledBy_WasmEnableStreamingResponse_InProject()
+        {
+            using var client = new HttpClient();
+            using var req = new HttpRequestMessage(HttpMethod.Get, LocalHttpEcho + "?guid=" + Guid.NewGuid());
+            using var response = await client.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);
+            Assert.Equal("BrowserHttpContent", response.Content.GetType().Name);
+            using var stream = await response.Content.ReadAsStreamAsync();
+            Assert.Equal("MemoryStream", stream.GetType().Name);
+            Assert.True(stream.CanSeek);
+        }
+
+        [Fact]
+        public async Task HttpStreamingEnabledBy_WebAssemblyEnableStreamingResponse_Option()
+        {
+            using var client = new HttpClient();
+            using var req = new HttpRequestMessage(HttpMethod.Get, LocalHttpEcho + "?guid=" + Guid.NewGuid());
+            req.Options.Set(new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse"), true);
+            using var response = await client.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);
+            Assert.Equal("StreamContent", response.Content.GetType().Name);
+            using var stream = await response.Content.ReadAsStreamAsync();
+            Assert.Equal("ReadOnlyStream", stream.GetType().Name);
+            Assert.False(stream.CanSeek);
+        }
+
         [Fact]
         public void Version_SetToNull_ThrowsArgumentNullException()
         {

src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System/Runtime/InteropServices/JavaScript/WebWorkerTest.Http.cs

@@ -32,7 +32,6 @@ await executor.Execute(async () =>
         }
 
         private static HttpRequestOptionsKey<bool> WebAssemblyEnableStreamingRequestKey = new("WebAssemblyEnableStreamingRequest");
-        private static HttpRequestOptionsKey<bool> WebAssemblyEnableStreamingResponseKey = new("WebAssemblyEnableStreamingResponse");
         private static string HelloJson = "{'hello':'world'}".Replace('\'', '"');
         private static string EchoStart = "{\"Method\":\"POST\",\"Url\":\"/Echo.ashx";
 
@@ -46,7 +45,6 @@ private async Task HttpClient_ActionInDifferentThread(string url, Executor execu
                 await ms.WriteAsync(Encoding.UTF8.GetBytes(HelloJson));
 
                 using var req = new HttpRequestMessage(HttpMethod.Post, url);
-                req.Options.Set(WebAssemblyEnableStreamingResponseKey, true);
                 req.Content = new StreamContent(ms);
                 using var client = new HttpClient();
                 var pr = client.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);

src/mono/browser/browser.proj

@@ -19,6 +19,7 @@
     <ICULibDir Condition="'$(WasmEnableThreads)' != 'true'">$([MSBuild]::NormalizeDirectory('$(PkgMicrosoft_NETCore_Runtime_ICU_Transport)', 'runtimes', 'browser-wasm', 'native', 'lib'))</ICULibDir>
     <ICULibDir Condition="'$(WasmEnableThreads)' == 'true'">$([MSBuild]::NormalizeDirectory('$(PkgMicrosoft_NETCore_Runtime_ICU_Transport)', 'runtimes', 'browser-wasm-threads', 'native', 'lib'))</ICULibDir>
     <InvariantTimezone Condition="'$(InvariantTimezone)' == ''">false</InvariantTimezone>
+    <WasmEnableStreamingResponse Condition="'$(WasmEnableStreamingResponse)' == ''">true</WasmEnableStreamingResponse>
     <InvariantGlobalization Condition="'$(InvariantGlobalization)' == ''">false</InvariantGlobalization>
     <WasmNativeStrip Condition="'$(WasmNativeStrip)' == ''">true</WasmNativeStrip>
     <WasmSingleFileBundle Condition="'$(WasmSingleFileBundle)' == ''">false</WasmSingleFileBundle>
@@ -335,6 +336,7 @@
     "PropertiesThatTriggerRelinking": [
       { "identity": "InvariantTimezone",            "defaultValueInRuntimePack": "$(InvariantTimezone)" },
       { "identity": "InvariantGlobalization",       "defaultValueInRuntimePack": "$(InvariantGlobalization)" },
+      { "identity": "WasmEnableStreamingResponse",  "defaultValueInRuntimePack": "$(WasmEnableStreamingResponse)" },
       { "identity": "WasmNativeStrip",              "defaultValueInRuntimePack": "$(WasmNativeStrip)" },
       { "identity": "WasmSingleFileBundle",         "defaultValueInRuntimePack": "$(WasmSingleFileBundle)" },
       { "identity": "WasmEnableSIMD",               "defaultValueInRuntimePack": "$(WasmEnableSIMD)" },

src/mono/browser/build/BrowserWasmApp.targets

@@ -59,8 +59,18 @@
     <_WasmDefaultFlags Condition="'$(WasmEnableSIMD)' == 'true'">-msimd128</_WasmDefaultFlags>
 
     <_WasmOutputFileName Condition="'$(WasmSingleFileBundle)' != 'true'">dotnet.native.wasm</_WasmOutputFileName>
+
+    <WasmEnableStreamingResponse Condition="'$(WasmEnableStreamingResponse)' == ''">true</WasmEnableStreamingResponse>
   </PropertyGroup>
 
+
+  <ItemGroup>
+    <RuntimeHostConfigurationOption Include="System.Net.Http.WasmEnableStreamingResponse"
+                                        Condition="'$(WasmEnableStreamingResponse)' != ''"
+                                        Value="$(WasmEnableStreamingResponse)"
+                                        Trim="true" />
+  </ItemGroup>
+
   <ItemGroup>
     <!-- Allow running/debugging from VS -->
     <ProjectCapability Include="DotNetCoreWeb"/>

src/mono/browser/runtime/http.ts

@@ -26,11 +26,7 @@ function commonAsserts (controller: HttpController) {
     mono_assert(controller, "expected controller");
 }
 
-let http_wasm_supports_streaming_request_cached: boolean | undefined;
 export function http_wasm_supports_streaming_request (): boolean {
-    if (http_wasm_supports_streaming_request_cached !== undefined) {
-        return http_wasm_supports_streaming_request_cached;
-    }
     // Detecting streaming request support works like this:
     // If the browser doesn't support a particular body type, it calls toString() on the object and uses the result as the body.
     // So, if the browser doesn't support request streams, the request body becomes the string "[object ReadableStream]".
@@ -48,20 +44,13 @@ export function http_wasm_supports_streaming_request (): boolean {
                 return "half";
             },
         } as RequestInit /* https://github.com/microsoft/TypeScript-DOM-lib-generator/issues/1483 */).headers.has("Content-Type");
-        http_wasm_supports_streaming_request_cached = duplexAccessed && !hasContentType;
-    } else {
-        http_wasm_supports_streaming_request_cached = false;
+        return duplexAccessed && !hasContentType;
     }
-    return http_wasm_supports_streaming_request_cached;
+    return false;
 }
 
-let http_wasm_supports_streaming_response_cached: boolean | undefined;
 export function http_wasm_supports_streaming_response (): boolean {
-    if (http_wasm_supports_streaming_response_cached !== undefined) {
-        return http_wasm_supports_streaming_response_cached;
-    }
-    http_wasm_supports_streaming_response_cached = typeof Response !== "undefined" && "body" in Response.prototype && typeof ReadableStream === "function";
-    return http_wasm_supports_streaming_response_cached;
+    return typeof Response !== "undefined" && "body" in Response.prototype && typeof ReadableStream === "function";
 }
 
 export function http_wasm_create_controller (): HttpController {

src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WasmFeatures.props

@@ -8,5 +8,6 @@
     <EnableUnsafeUTF7Encoding Condition="'$(EnableUnsafeUTF7Encoding)' == ''">false</EnableUnsafeUTF7Encoding>
     <HttpActivityPropagationSupport Condition="'$(HttpActivityPropagationSupport)' == ''">false</HttpActivityPropagationSupport>
     <DebuggerSupport Condition="'$(DebuggerSupport)' == '' and '$(Configuration)' != 'Debug'">false</DebuggerSupport>
+    <WasmEnableStreamingResponse Condition="'$(WasmEnableStreamingResponse)' == ''">true</WasmEnableStreamingResponse>
   </PropertyGroup>
 </Project>

src/mono/wasm/features.md

@@ -55,6 +55,14 @@ Because web browsers do not expose direct access to sockets, we are unable to pr
 
 A prominent limitation is that your application must obey `Cross-Origin Resource Sharing` (CORS) rules in order to perform network requests successfully - see [CORS on MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) for more information.
 
+Since Net 10 Preview 3 the HTTP client supports [streaming HTTP response](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Using_readable_streams#consuming_a_fetch_as_a_stream) by default because all evergreen browsers now support it.
+
+This is a breaking change because the `response.Content.ReadAsStreamAsync()` is no longer `MemoryStream` but `BrowserHttpReadStream` which doesn't support synchronous operations like `Stream.Read(Span<Byte>)`. If your code uses synchronous operations, you can disable the feature or copy the stream into `MemoryStream` yourself.
+
+If you need to disable it, you can use `<WasmEnableStreamingResponse>false</WasmEnableStreamingResponse>` or `DOTNET_WASM_ENABLE_STREAMING_RESPONSE` env variable to do it for all HTTP requests.
+
+Or you can use `request.Options.Set(new HttpRequestOptionsKey<bool>("WebAssemblyEnableStreamingResponse"), false);` for individual request.
+
 ### WebSocket
 Applications using the [WebSocketClient](https://learn.microsoft.com/dotnet/api/system.net.websockets.clientwebsocket) managed API will require the browser to support the [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API) API.