Implement dynamic HTTP/2 window scaling

src/libraries/Common/src/System/Net/Http/HttpHandlerDefaults.cs

@@ -28,5 +28,7 @@ internal static partial class HttpHandlerDefaults
         public static readonly TimeSpan DefaultPooledConnectionIdleTimeout = TimeSpan.FromMinutes(1);
         public static readonly TimeSpan DefaultExpect100ContinueTimeout = TimeSpan.FromSeconds(1);
         public static readonly TimeSpan DefaultConnectTimeout = Timeout.InfiniteTimeSpan;
+        public const int DefaultHttp2MaxStreamWindowSize = 16 * 1024 * 1024;
+        public const double DefaultHttp2StreamWindowScaleThresholdMultiplier = 1.0;
     }
 }

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

@@ -25,6 +25,8 @@ public class Http2LoopbackConnection : GenericLoopbackConnection
         private TaskCompletionSource<bool> _ignoredSettingsAckPromise;
         private bool _ignoreWindowUpdates;
         private TaskCompletionSource<PingFrame> _expectPingFrame;
+        private bool _autoProcessPingFrames;
+        private bool _respondToPing;
         private readonly TimeSpan _timeout;
         private int _lastStreamId;
 
@@ -121,11 +123,11 @@ public async Task SendConnectionPrefaceAsync()
             clientSettings = await ReadFrameAsync(_timeout).ConfigureAwait(false);
         }
 
-        public async Task WriteFrameAsync(Frame frame)
+        public async Task WriteFrameAsync(Frame frame, CancellationToken cancellationToken = default)
         {
             byte[] writeBuffer = new byte[Frame.FrameHeaderLength + frame.Length];
             frame.WriteTo(writeBuffer);
-            await _connectionStream.WriteAsync(writeBuffer, 0, writeBuffer.Length).ConfigureAwait(false);
+            await _connectionStream.WriteAsync(writeBuffer, 0, writeBuffer.Length, cancellationToken).ConfigureAwait(false);
         }
 
         // Read until the buffer is full
@@ -159,7 +161,7 @@ public async Task<Frame> ReadFrameAsync(TimeSpan timeout)
             return await ReadFrameAsync(timeoutCts.Token).ConfigureAwait(false);
         }
 
-        private async Task<Frame> ReadFrameAsync(CancellationToken cancellationToken)
+        public async Task<Frame> ReadFrameAsync(CancellationToken cancellationToken)
         {
             // First read the frame headers, which should tell us how long the rest of the frame is.
             byte[] headerBytes = new byte[Frame.FrameHeaderLength];
@@ -200,9 +202,18 @@ private async Task<Frame> ReadFrameAsync(CancellationToken cancellationToken)
 
             if (_expectPingFrame != null && header.Type == FrameType.Ping)
             {
-                _expectPingFrame.SetResult(PingFrame.ReadFrom(header, data));
-                _expectPingFrame = null;
-                return await ReadFrameAsync(cancellationToken).ConfigureAwait(false);
+                PingFrame pingFrame = PingFrame.ReadFrom(header, data);
+
+                // _expectPingFrame is not intended to work with PING ACK:
+                if (!pingFrame.AckFlag)
+                {
+                    await ProcessExpectedPingFrameAsync(pingFrame);
+                    return await ReadFrameAsync(cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    return pingFrame;
+                }
             }
 
             // Construct the correct frame type and return it.
@@ -224,11 +235,30 @@ private async Task<Frame> ReadFrameAsync(CancellationToken cancellationToken)
                     return GoAwayFrame.ReadFrom(header, data);
                 case FrameType.Continuation:
                     return ContinuationFrame.ReadFrom(header, data);
+                case FrameType.WindowUpdate:
+                    return WindowUpdateFrame.ReadFrom(header, data);
                 default:
                     return header;
             }
         }
 
+        private async Task ProcessExpectedPingFrameAsync(PingFrame pingFrame)
+        {
+            _expectPingFrame.SetResult(pingFrame);
+            if (_respondToPing && !pingFrame.AckFlag)
+            {
+                await SendPingAckAsync(pingFrame.Data);
+            }
+
+            _expectPingFrame = null;
+            _respondToPing = false;
+
+            if (_autoProcessPingFrames)
+            {
+                _ = ExpectPingFrameAsync(true);
+            }
+        }
+
         // Reset and return underlying networking objects.
         public (SocketWrapper, Stream) ResetNetwork()
         {
@@ -263,15 +293,32 @@ public void IgnoreWindowUpdates()
             _ignoreWindowUpdates = true;
         }
 
-        // Set up loopback server to expect PING frames among other frames.
+        // Set up loopback server to expect a (non-ACK) PING frame among other frames.
         // Once PING frame is read in ReadFrameAsync, the returned task is completed.
         // The returned task is canceled in ReadPingAsync if no PING frame has been read so far.
-        public Task<PingFrame> ExpectPingFrameAsync()
+        public Task<PingFrame> ExpectPingFrameAsync(bool respond = false)
         {
             _expectPingFrame ??= new TaskCompletionSource<PingFrame>();
+            _respondToPing = respond;
+
             return _expectPingFrame.Task;
         }
 
+        // Recurring variant of ExpectPingFrame().
+        // Starting from the time of the call, respond to all (non-ACK) PING frames which are received among other frames.
+        public void SetupAutomaticPingResponse()
+        {
+            _autoProcessPingFrames = true;
+            _ = ExpectPingFrameAsync(true);
+        }
+
+        // Tear down automatic PING responses, but still expect (at most one) PING in flight
+        public void TearDownAutomaticPingResponse()
+        {
+            _respondToPing = false;
+            _autoProcessPingFrames = false;
+        }
+
         public async Task ReadRstStreamAsync(int streamId)
         {
             Frame frame = await ReadFrameAsync(_timeout);
@@ -292,6 +339,14 @@ public async Task ReadRstStreamAsync(int streamId)
             }
         }
 
+        // Receive a single PING frame and respond with an ACK
+        public async Task RespondToPingFrameAsync()
+        {
+            PingFrame pingFrame = (PingFrame)await ReadFrameAsync(_timeout);
+            Assert.False(pingFrame.AckFlag, "Unexpected PING ACK");
+            await SendPingAckAsync(pingFrame.Data);
+        }
+
         // Wait for the client to close the connection, e.g. after the HttpClient is disposed.
         public async Task WaitForClientDisconnectAsync(bool ignoreUnexpectedFrames = false)
         {
@@ -720,18 +775,23 @@ public async Task PingPong()
             PingFrame ping = new PingFrame(pingData, FrameFlags.None, 0);
             await WriteFrameAsync(ping).ConfigureAwait(false);
             PingFrame pingAck = (PingFrame)await ReadFrameAsync(_timeout).ConfigureAwait(false);
+
             if (pingAck == null || pingAck.Type != FrameType.Ping || !pingAck.AckFlag)
             {
-                throw new Exception("Expected PING ACK");
+                string faultDetails = pingAck == null ? "" : $" frame.Type:{pingAck.Type} frame.AckFlag: {pingAck.AckFlag}";
+                throw new Exception("Expected PING ACK" + faultDetails);
             }
 
             Assert.Equal(pingData, pingAck.Data);
         }
 
+        public Task<PingFrame> ReadPingAsync() => ReadPingAsync(_timeout);
+
         public async Task<PingFrame> ReadPingAsync(TimeSpan timeout)
         {
             _expectPingFrame?.TrySetCanceled();
             _expectPingFrame = null;
+            _respondToPing = false;
 
             Frame frame = await ReadFrameAsync(timeout).ConfigureAwait(false);
             Assert.NotNull(frame);
@@ -743,7 +803,7 @@ public async Task<PingFrame> ReadPingAsync(TimeSpan timeout)
             return Assert.IsAssignableFrom<PingFrame>(frame);
         }
 
-        public async Task SendPingAckAsync(long payload)
+        public async Task SendPingAckAsync(long payload, CancellationToken cancellationToken = default)
         {
             PingFrame pingAck = new PingFrame(payload, FrameFlags.Ack, 0);
             await WriteFrameAsync(pingAck).ConfigureAwait(false);

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

@@ -1475,6 +1475,11 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             {
                 await server.AcceptConnectionAsync(async connection =>
                 {
+                    if (connection is Http2LoopbackConnection http2Connection)
+                    {
+                        http2Connection.SetupAutomaticPingResponse(); // Handle RTT PING
+                    }
+
                     // Send unexpected 1xx responses.
                     HttpRequestData requestData = await connection.ReadRequestDataAsync(readBody: false);
                     await connection.SendResponseAsync(responseStatusCode, isFinal: false);
@@ -1524,6 +1529,10 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                 await server.AcceptConnectionAsync(async connection =>
                 {
                     await connection.ReadRequestDataAsync(readBody: false);
+                    if (connection is Http2LoopbackConnection http2Connection)
+                    {
+                        http2Connection.SetupAutomaticPingResponse(); // Respond to RTT PING
+                    }
                     // Send multiple 100-Continue responses.
                     for (int count = 0 ; count < 4; count++)
                     {
@@ -1627,6 +1636,11 @@ await server.AcceptConnectionAsync(async connection =>
 
                     await connection.SendResponseAsync(HttpStatusCode.OK, headers: new HttpHeaderData[] {new HttpHeaderData("Content-Length", $"{ResponseString.Length}")}, isFinal : false);
 
+                    if (connection is Http2LoopbackConnection http2Connection)
+                    {
+                        http2Connection.SetupAutomaticPingResponse(); // Respond to RTT PING
+                    }
+
                     byte[] body = await connection.ReadRequestBodyAsync();
                     Assert.Equal(RequestString, Encoding.ASCII.GetString(body));
 

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

@@ -50,6 +50,8 @@ protected static HttpClient CreateHttpClient(HttpMessageHandler handler, string
 #endif
             };
 
+        public const int DefaultInitialWindowSize = 65535;
+
         public static readonly bool[] BoolValues = new[] { true, false };
 
         // For use by remote server tests

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

@@ -353,6 +353,7 @@ protected override void SerializeToStream(System.IO.Stream stream, System.Net.Tr
     public sealed partial class SocketsHttpHandler : System.Net.Http.HttpMessageHandler
     {
         public SocketsHttpHandler() { }
+        public int InitialHttp2StreamWindowSize { get { throw null; } set { } }
         [System.Runtime.Versioning.UnsupportedOSPlatformGuardAttribute("browser")]
         public static bool IsSupported { get { throw null; } }
         public bool AllowAutoRedirect { get { throw null; } set { } }

src/libraries/System.Net.Http/src/Resources/Strings.resx

@@ -429,6 +429,9 @@
   <data name="net_http_http2_connection_not_established" xml:space="preserve">
     <value>An HTTP/2 connection could not be established because the server did not complete the HTTP/2 handshake.</value>
   </data>
+  <data name="net_http_http2_invalidinitialstreamwindowsize" xml:space="preserve">
+    <value>The initial HTTP/2 stream window size must be between {0} and {1}.</value>
+  </data>
   <data name="net_MethodNotImplementedException" xml:space="preserve">
     <value>This method is not implemented by this class.</value>
   </data>

src/libraries/System.Net.Http/src/System.Net.Http.csproj

@@ -62,6 +62,7 @@
     <Compile Include="System\Net\Http\ReadOnlyMemoryContent.cs" />
     <Compile Include="System\Net\Http\RequestRetryType.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\HttpMessageHandlerStage.cs" />
+    <Compile Include="System\Net\Http\SocketsHttpHandler\RuntimeSettingParser.cs" />
     <Compile Include="System\Net\Http\StreamContent.cs" />
     <Compile Include="System\Net\Http\StreamToStreamCopy.cs" />
     <Compile Include="System\Net\Http\StringContent.cs" />
@@ -160,6 +161,7 @@
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2ProtocolException.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2Stream.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2StreamException.cs" />
+    <Compile Include="System\Net\Http\SocketsHttpHandler\Http2StreamWindowManager.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http3Connection.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http3ConnectionException.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http3ProtocolException.cs" />

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

@@ -25,6 +25,12 @@ public bool UseCookies
             set => throw new PlatformNotSupportedException();
         }
 
+        public int InitialHttp2StreamWindowSize
+        {
+            get => throw new PlatformNotSupportedException();
+            set => throw new PlatformNotSupportedException();
+        }
+
         [AllowNull]
         public CookieContainer CookieContainer
         {

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

@@ -28,25 +28,8 @@ internal sealed class DiagnosticsHandler : DelegatingHandler
 
         public static bool IsGloballyEnabled { get; } = GetEnableActivityPropagationValue();
 
-        private static bool GetEnableActivityPropagationValue()
-        {
-            // First check for the AppContext switch, giving it priority over the environment variable.
-            if (AppContext.TryGetSwitch(Namespace + ".EnableActivityPropagation", out bool enableActivityPropagation))
-            {
-                return enableActivityPropagation;
-            }
-
-            // AppContext switch wasn't used. Check the environment variable to determine which handler should be used.
-            string? envVar = Environment.GetEnvironmentVariable("DOTNET_SYSTEM_NET_HTTP_ENABLEACTIVITYPROPAGATION");
-            if (envVar != null && (envVar.Equals("false", StringComparison.OrdinalIgnoreCase) || envVar.Equals("0")))
-            {
-                // Suppress Activity propagation.
-                return false;
-            }
-
-            // Defaults to enabling Activity propagation.
-            return true;
-        }
+        private static bool GetEnableActivityPropagationValue() =>
+            RuntimeSettingParser.QueryRuntimeSettingSwitch(Namespace + ".EnableActivityPropagation", "DOTNET_SYSTEM_NET_HTTP_ENABLEACTIVITYPROPAGATION", true);
 
         public DiagnosticsHandler(HttpMessageHandler innerHandler) : base(innerHandler)
         {