Review feedback

ladeak · ladeak · commit 750c157a4355 · 2024-04-25T18:08:53.000+02:00
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http2/Http2FrameWriter.cs b/src/Servers/Kestrel/Core/src/Internal/Http2/Http2FrameWriter.cs
@@ -487,9 +487,9 @@ private void WriteResponseHeadersUnsynchronized(int streamId, int statusCode, Ht
             _headersEnumerator.Initialize(headers);
             _outgoingFrame.PrepareHeaders(headerFrameFlags, streamId);
             _headerEncodingBuffer.ResetWrittenCount();
-            var buffer = _headerEncodingBuffer.GetSpan(_maxFrameSize)[0.._maxFrameSize];
+            var buffer = _headerEncodingBuffer.GetSpan(_maxFrameSize)[0.._maxFrameSize]; // GetSpan might return more data that can result in a less deterministic behavior on the way headers are split into frames.
             var done = HPackHeaderWriter.BeginEncodeHeaders(statusCode, _hpackEncoder, _headersEnumerator, buffer, out var payloadLength);
-            Debug.Assert(done != HeaderWriteResult.BufferTooSmall, "Oversized frames should not be returned, beucase this always writes the status.");
+            Debug.Assert(done != HPackHeaderWriter.HeaderWriteResult.BufferTooSmall, "Oversized frames should not be returned, beucase this always writes the status.");
             _headerEncodingBuffer.Advance(payloadLength);
             FinishWritingHeaders(streamId, payloadLength, done);
         }
@@ -529,16 +529,16 @@ private ValueTask<FlushResult> WriteDataAndTrailersAsync(Http2Stream stream, in
             try
             {
                 _outgoingFrame.PrepareHeaders(Http2HeadersFrameFlags.END_STREAM, streamId);
-                HeaderWriteResult done = HeaderWriteResult.MoreHeaders;
+                var done = HPackHeaderWriter.HeaderWriteResult.MoreHeaders;
                 int payloadLength;
                 do
                 {
                     _headersEnumerator.Initialize(headers);
                     _headerEncodingBuffer.ResetWrittenCount();
-                    var bufferSize = done == HeaderWriteResult.BufferTooSmall ? _headerEncodingBuffer.Capacity * 2 : _headerEncodingBuffer.Capacity;
-                    var buffer = _headerEncodingBuffer.GetSpan(bufferSize)[0..bufferSize];
+                    var bufferSize = done == HPackHeaderWriter.HeaderWriteResult.BufferTooSmall ? _headerEncodingBuffer.Capacity * 2 : _headerEncodingBuffer.Capacity;
+                    var buffer = _headerEncodingBuffer.GetSpan(bufferSize)[0..bufferSize]; // GetSpan might return more data that can result in a less deterministic behavior on the way headers are split into frames.
                     done = HPackHeaderWriter.BeginEncodeHeaders(_hpackEncoder, _headersEnumerator, buffer, out payloadLength);
-                } while (done == HeaderWriteResult.BufferTooSmall);
+                } while (done == HPackHeaderWriter.HeaderWriteResult.BufferTooSmall);
                 _headerEncodingBuffer.Advance(payloadLength);
                 FinishWritingHeaders(streamId, payloadLength, done);
             }
@@ -554,7 +554,7 @@ private ValueTask<FlushResult> WriteDataAndTrailersAsync(Http2Stream stream, in
         }
     }
 
-    private void SplitHeaderFramesToOutput(int streamId, HeaderWriteResult done, bool isFramePrepared)
+    private void SplitHeaderFramesToOutput(int streamId, HPackHeaderWriter.HeaderWriteResult done, bool isFramePrepared)
     {
         var dataToFrame = _headerEncodingBuffer.WrittenSpan;
         var shouldPrepareFrame = !isFramePrepared;
@@ -569,9 +569,9 @@ private void SplitHeaderFramesToOutput(int streamId, HeaderWriteResult done, boo
                 shouldPrepareFrame = true;
             }
 
-            var currentSize = dataToFrame.Length > _maxFrameSize ? _maxFrameSize : dataToFrame.Length;
+            var currentSize = Math.Min(dataToFrame.Length, _maxFrameSize);
             _outgoingFrame.PayloadLength = currentSize;
-            if (done == HeaderWriteResult.Done && dataToFrame.Length == currentSize)
+            if (done == HPackHeaderWriter.HeaderWriteResult.Done && dataToFrame.Length == currentSize)
             {
                 _outgoingFrame.HeadersFlags |= Http2HeadersFrameFlags.END_HEADERS;
             }
@@ -582,13 +582,13 @@ private void SplitHeaderFramesToOutput(int streamId, HeaderWriteResult done, boo
         }
     }
 
-    private void FinishWritingHeaders(int streamId, int payloadLength, HeaderWriteResult done)
+    private void FinishWritingHeaders(int streamId, int payloadLength, HPackHeaderWriter.HeaderWriteResult done)
     {
         SplitHeaderFramesToOutput(streamId, done, isFramePrepared: true);
-        while (done != HeaderWriteResult.Done)
+        while (done != HPackHeaderWriter.HeaderWriteResult.Done)
         {
             _headerEncodingBuffer.ResetWrittenCount();
-            var bufferSize = done == HeaderWriteResult.BufferTooSmall ? _headerEncodingBuffer.Capacity * 2 : _headerEncodingBuffer.Capacity;
+            var bufferSize = done == HPackHeaderWriter.HeaderWriteResult.BufferTooSmall ? _headerEncodingBuffer.Capacity * 2 : _headerEncodingBuffer.Capacity;
             var buffer = _headerEncodingBuffer.GetSpan(bufferSize)[0..bufferSize];
             done = HPackHeaderWriter.ContinueEncodeHeaders(_hpackEncoder, _headersEnumerator, buffer, out payloadLength);
             _headerEncodingBuffer.Advance(payloadLength);
diff --git a/src/Servers/Kestrel/Core/test/Http2/Http2HPackEncoderTests.cs b/src/Servers/Kestrel/Core/test/Http2/Http2HPackEncoderTests.cs
@@ -29,7 +29,7 @@ public void BeginEncodeHeaders_Status302_NewIndexValue()
         enumerator.Initialize(headers);
 
         var hpackEncoder = new DynamicHPackEncoder();
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(302, hpackEncoder, enumerator, buffer, out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(302, hpackEncoder, enumerator, buffer, out var length));
 
         var result = buffer.Slice(0, length).ToArray();
         var hex = BitConverter.ToString(result);
@@ -52,7 +52,7 @@ public void BeginEncodeHeaders_CacheControlPrivate_NewIndexValue()
         enumerator.Initialize(headers);
 
         var hpackEncoder = new DynamicHPackEncoder();
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(302, hpackEncoder, enumerator, buffer, out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(302, hpackEncoder, enumerator, buffer, out var length));
 
         var result = buffer.Slice(5, length - 5).ToArray();
         var hex = BitConverter.ToString(result);
@@ -81,7 +81,7 @@ public void BeginEncodeHeaders_MaxHeaderTableSizeExceeded_EvictionsToFit()
 
         // First response
         enumerator.Initialize(headers);
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(302, hpackEncoder, enumerator, buffer, out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(302, hpackEncoder, enumerator, buffer, out var length));
 
         var result = buffer.Slice(0, length).ToArray();
         var hex = BitConverter.ToString(result);
@@ -123,7 +123,7 @@ public void BeginEncodeHeaders_MaxHeaderTableSizeExceeded_EvictionsToFit()
 
         // Second response
         enumerator.Initialize(headers);
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(307, hpackEncoder, enumerator, buffer, out length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(307, hpackEncoder, enumerator, buffer, out length));
 
         result = buffer.Slice(0, length).ToArray();
         hex = BitConverter.ToString(result);
@@ -164,7 +164,7 @@ public void BeginEncodeHeaders_MaxHeaderTableSizeExceeded_EvictionsToFit()
         headers.SetCookie = "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1";
 
         enumerator.Initialize(headers);
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(200, hpackEncoder, enumerator, buffer, out length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(200, hpackEncoder, enumerator, buffer, out length));
 
         result = buffer.Slice(0, length).ToArray();
         hex = BitConverter.ToString(result);
@@ -225,7 +225,7 @@ public void BeginEncodeHeadersCustomEncoding_MaxHeaderTableSizeExceeded_Eviction
 
         // First response
         enumerator.Initialize((HttpResponseHeaders)headers);
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(302, hpackEncoder, enumerator, buffer, out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(302, hpackEncoder, enumerator, buffer, out var length));
 
         var result = buffer.Slice(0, length).ToArray();
         var hex = BitConverter.ToString(result);
@@ -267,7 +267,7 @@ public void BeginEncodeHeadersCustomEncoding_MaxHeaderTableSizeExceeded_Eviction
 
         // Second response
         enumerator.Initialize(headers);
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(307, hpackEncoder, enumerator, buffer, out length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(307, hpackEncoder, enumerator, buffer, out length));
 
         result = buffer.Slice(0, length).ToArray();
         hex = BitConverter.ToString(result);
@@ -308,7 +308,7 @@ public void BeginEncodeHeadersCustomEncoding_MaxHeaderTableSizeExceeded_Eviction
         headers.SetCookie = "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1";
 
         enumerator.Initialize(headers);
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(200, hpackEncoder, enumerator, buffer, out length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(200, hpackEncoder, enumerator, buffer, out length));
 
         result = buffer.Slice(0, length).ToArray();
         hex = BitConverter.ToString(result);
@@ -366,7 +366,7 @@ public void BeginEncodeHeaders_ExcludedHeaders_NotAddedToTable(string headerName
         enumerator.Initialize(headers);
 
         var hpackEncoder = new DynamicHPackEncoder(maxHeaderTableSize: Http2PeerSettings.DefaultHeaderTableSize);
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, enumerator, buffer, out _));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, enumerator, buffer, out _));
 
         if (neverIndex)
         {
@@ -392,7 +392,7 @@ public void BeginEncodeHeaders_HeaderExceedHeaderTableSize_NoIndexAndNoHeaderEnt
         enumerator.Initialize(headers);
 
         var hpackEncoder = new DynamicHPackEncoder();
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(200, hpackEncoder, enumerator, buffer, out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(200, hpackEncoder, enumerator, buffer, out var length));
 
         Assert.Empty(GetHeaderEntries(hpackEncoder));
     }
@@ -482,11 +482,11 @@ public void EncodesHeadersInSinglePayloadWhenSpaceAvailable(KeyValuePair<string,
         var length = 0;
         if (statusCode.HasValue)
         {
-            Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(statusCode.Value, hpackEncoder, GetHeadersEnumerator(headers), payload, out length));
+            Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(statusCode.Value, hpackEncoder, GetHeadersEnumerator(headers), payload, out length));
         }
         else
         {
-            Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, GetHeadersEnumerator(headers), payload, out length));
+            Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, GetHeadersEnumerator(headers), payload, out length));
         }
         Assert.Equal(expectedPayload.Length, length);
 
@@ -548,28 +548,28 @@ public void EncodesHeadersInMultiplePayloadsWhenSpaceNotAvailable(bool exactSize
 
         // When !exactSize, slices are one byte short of fitting the next header
         var sliceLength = expectedStatusCodePayload.Length + (exactSize ? 0 : expectedDateHeaderPayload.Length - 1);
-        Assert.Equal(HeaderWriteResult.MoreHeaders, HPackHeaderWriter.BeginEncodeHeaders(statusCode, hpackEncoder, headerEnumerator, payload.Slice(offset, sliceLength), out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.MoreHeaders, HPackHeaderWriter.BeginEncodeHeaders(statusCode, hpackEncoder, headerEnumerator, payload.Slice(offset, sliceLength), out var length));
         Assert.Equal(expectedStatusCodePayload.Length, length);
         Assert.Equal(expectedStatusCodePayload, payload.Slice(0, length).ToArray());
 
         offset += length;
 
         sliceLength = expectedDateHeaderPayload.Length + (exactSize ? 0 : expectedContentTypeHeaderPayload.Length - 1);
-        Assert.Equal(HeaderWriteResult.MoreHeaders, HPackHeaderWriter.ContinueEncodeHeaders(hpackEncoder, headerEnumerator, payload.Slice(offset, sliceLength), out length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.MoreHeaders, HPackHeaderWriter.ContinueEncodeHeaders(hpackEncoder, headerEnumerator, payload.Slice(offset, sliceLength), out length));
         Assert.Equal(expectedDateHeaderPayload.Length, length);
         Assert.Equal(expectedDateHeaderPayload, payload.Slice(offset, length).ToArray());
 
         offset += length;
 
         sliceLength = expectedContentTypeHeaderPayload.Length + (exactSize ? 0 : expectedServerHeaderPayload.Length - 1);
-        Assert.Equal(HeaderWriteResult.MoreHeaders, HPackHeaderWriter.ContinueEncodeHeaders(hpackEncoder, headerEnumerator, payload.Slice(offset, sliceLength), out length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.MoreHeaders, HPackHeaderWriter.ContinueEncodeHeaders(hpackEncoder, headerEnumerator, payload.Slice(offset, sliceLength), out length));
         Assert.Equal(expectedContentTypeHeaderPayload.Length, length);
         Assert.Equal(expectedContentTypeHeaderPayload, payload.Slice(offset, length).ToArray());
 
         offset += length;
 
         sliceLength = expectedServerHeaderPayload.Length;
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.ContinueEncodeHeaders(hpackEncoder, headerEnumerator, payload.Slice(offset, sliceLength), out length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.ContinueEncodeHeaders(hpackEncoder, headerEnumerator, payload.Slice(offset, sliceLength), out length));
         Assert.Equal(expectedServerHeaderPayload.Length, length);
         Assert.Equal(expectedServerHeaderPayload, payload.Slice(offset, length).ToArray());
     }
@@ -586,7 +586,7 @@ public void BeginEncodeHeaders_MaxHeaderTableSizeUpdated_SizeUpdateInHeaders()
 
         // First request
         enumerator.Initialize(new Dictionary<string, StringValues>());
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, enumerator, buffer, out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, enumerator, buffer, out var length));
 
         Assert.Equal(2, length);
 
@@ -600,7 +600,7 @@ public void BeginEncodeHeaders_MaxHeaderTableSizeUpdated_SizeUpdateInHeaders()
 
         // Second request
         enumerator.Initialize(new Dictionary<string, StringValues>());
-        Assert.Equal(HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, enumerator, buffer, out length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.Done, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, enumerator, buffer, out length));
 
         Assert.Equal(0, length);
     }
@@ -616,7 +616,7 @@ public void WithStatusCode_TooLargeHeader_ReturnsNotDone()
         enumerator.Initialize(headers);
 
         var hpackEncoder = new DynamicHPackEncoder();
-        Assert.Equal(HeaderWriteResult.MoreHeaders, HPackHeaderWriter.BeginEncodeHeaders(200, hpackEncoder, enumerator, buffer, out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.MoreHeaders, HPackHeaderWriter.BeginEncodeHeaders(200, hpackEncoder, enumerator, buffer, out var length));
     }
 
     [Fact]
@@ -630,7 +630,7 @@ public void NoStatusCodeLargeHeader_ReturnsOversized()
         enumerator.Initialize(headers);
 
         var hpackEncoder = new DynamicHPackEncoder();
-        Assert.Equal(HeaderWriteResult.BufferTooSmall, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, enumerator, buffer, out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.BufferTooSmall, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, enumerator, buffer, out var length));
     }
 
     [Fact]
@@ -644,7 +644,7 @@ public void WithStatusCode_JustFittingHeaderNoSpace_ReturnsNotDone()
         enumerator.Initialize(headers);
 
         var hpackEncoder = new DynamicHPackEncoder();
-        Assert.Equal(HeaderWriteResult.MoreHeaders, HPackHeaderWriter.BeginEncodeHeaders(200, hpackEncoder, enumerator, buffer, out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.MoreHeaders, HPackHeaderWriter.BeginEncodeHeaders(200, hpackEncoder, enumerator, buffer, out var length));
     }
 
     [Fact]
@@ -659,7 +659,7 @@ public void NoStatusCode_JustFittingHeaderNoSpace_ReturnsNotDone()
         enumerator.Initialize(headers);
 
         var hpackEncoder = new DynamicHPackEncoder();
-        Assert.Equal(HeaderWriteResult.MoreHeaders, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, enumerator, buffer, out var length));
+        Assert.Equal(HPackHeaderWriter.HeaderWriteResult.MoreHeaders, HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, enumerator, buffer, out var length));
     }
 
     private static Http2HeadersEnumerator GetHeadersEnumerator(IEnumerable<KeyValuePair<string, string>> headers)
diff --git a/src/Servers/Kestrel/shared/HPackHeaderWriter.cs b/src/Servers/Kestrel/shared/HPackHeaderWriter.cs
@@ -10,22 +10,22 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2;
 namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests;
 #endif
 
-internal enum HeaderWriteResult : byte
-{
-    // Not all headers written.
-    MoreHeaders = 0,
-
-    // All headers written.
-    Done = 1,
-
-    // Oversized header for the given buffer.
-    BufferTooSmall = 2,
-}
-
 // This file is used by Kestrel to write response headers and tests to write request headers.
 // To avoid adding test code to Kestrel this file is shared. Test specifc code is excluded from Kestrel by ifdefs.
 internal static class HPackHeaderWriter
 {
+    internal enum HeaderWriteResult : byte
+    {
+        // Not all headers written.
+        MoreHeaders = 0,
+
+        // All headers written.
+        Done = 1,
+
+        // Oversized header for the given buffer.
+        BufferTooSmall = 2,
+    }
+
     /// <summary>
     /// Begin encoding headers in the first HEADERS frame.
     /// </summary>
diff --git a/src/Servers/Kestrel/shared/test/PipeWriterHttp2FrameExtensions.cs b/src/Servers/Kestrel/shared/test/PipeWriterHttp2FrameExtensions.cs
@@ -36,7 +36,7 @@ public static void WriteStartStream(this PipeWriter writer, int streamId, Dynami
         var done = HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, headers, buffer, out var length);
         frame.PayloadLength = length;
 
-        if (done == Microsoft.AspNetCore.Server.Kestrel.Core.Tests.HeaderWriteResult.Done)
+        if (done == HPackHeaderWriter.HeaderWriteResult.Done)
         {
             frame.HeadersFlags = Http2HeadersFrameFlags.END_HEADERS;
         }
@@ -49,14 +49,14 @@ public static void WriteStartStream(this PipeWriter writer, int streamId, Dynami
         Http2FrameWriter.WriteHeader(frame, writer);
         writer.Write(buffer.Slice(0, length));
 
-        while (done != Microsoft.AspNetCore.Server.Kestrel.Core.Tests.HeaderWriteResult.Done)
+        while (done != HPackHeaderWriter.HeaderWriteResult.Done)
         {
             frame.PrepareContinuation(Http2ContinuationFrameFlags.NONE, streamId);
 
             done = HPackHeaderWriter.ContinueEncodeHeaders(hpackEncoder, headers, buffer, out length);
             frame.PayloadLength = length;
 
-            if (done == Microsoft.AspNetCore.Server.Kestrel.Core.Tests.HeaderWriteResult.Done)
+            if (done == HPackHeaderWriter.HeaderWriteResult.Done)
             {
                 frame.ContinuationFlags = Http2ContinuationFrameFlags.END_HEADERS;
             }
diff --git a/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http2/Http2TestBase.cs b/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http2/Http2TestBase.cs

Original file line number	Diff line number	Diff line change
`@@ -487,9 +487,9 @@ private void WriteResponseHeadersUnsynchronized(int streamId, int statusCode, Ht`
`487`	`487`	`_headersEnumerator.Initialize(headers);`
`488`	`488`	`_outgoingFrame.PrepareHeaders(headerFrameFlags, streamId);`
`489`	`489`	`_headerEncodingBuffer.ResetWrittenCount();`
`490`		`- var buffer = _headerEncodingBuffer.GetSpan(_maxFrameSize)[0.._maxFrameSize];`
	`490`	`+ var buffer = _headerEncodingBuffer.GetSpan(_maxFrameSize)[0.._maxFrameSize]; // GetSpan might return more data that can result in a less deterministic behavior on the way headers are split into frames.`
`491`	`491`	`var done = HPackHeaderWriter.BeginEncodeHeaders(statusCode, _hpackEncoder, _headersEnumerator, buffer, out var payloadLength);`
`492`		`- Debug.Assert(done != HeaderWriteResult.BufferTooSmall, "Oversized frames should not be returned, beucase this always writes the status.");`
	`492`	`+ Debug.Assert(done != HPackHeaderWriter.HeaderWriteResult.BufferTooSmall, "Oversized frames should not be returned, beucase this always writes the status.");`
`493`	`493`	`_headerEncodingBuffer.Advance(payloadLength);`
`494`	`494`	`FinishWritingHeaders(streamId, payloadLength, done);`
`495`	`495`	`}`
`@@ -529,16 +529,16 @@ private ValueTask<FlushResult> WriteDataAndTrailersAsync(Http2Stream stream, in`
`529`	`529`	`try`
`530`	`530`	`{`
`531`	`531`	`_outgoingFrame.PrepareHeaders(Http2HeadersFrameFlags.END_STREAM, streamId);`
`532`		`- HeaderWriteResult done = HeaderWriteResult.MoreHeaders;`
	`532`	`+ var done = HPackHeaderWriter.HeaderWriteResult.MoreHeaders;`
`533`	`533`	`int payloadLength;`
`534`	`534`	`do`
`535`	`535`	`{`
`536`	`536`	`_headersEnumerator.Initialize(headers);`
`537`	`537`	`_headerEncodingBuffer.ResetWrittenCount();`
`538`		`- var bufferSize = done == HeaderWriteResult.BufferTooSmall ? _headerEncodingBuffer.Capacity * 2 : _headerEncodingBuffer.Capacity;`
`539`		`- var buffer = _headerEncodingBuffer.GetSpan(bufferSize)[0..bufferSize];`
	`538`	`+ var bufferSize = done == HPackHeaderWriter.HeaderWriteResult.BufferTooSmall ? _headerEncodingBuffer.Capacity * 2 : _headerEncodingBuffer.Capacity;`
	`539`	`+ var buffer = _headerEncodingBuffer.GetSpan(bufferSize)[0..bufferSize]; // GetSpan might return more data that can result in a less deterministic behavior on the way headers are split into frames.`
`540`	`540`	`done = HPackHeaderWriter.BeginEncodeHeaders(_hpackEncoder, _headersEnumerator, buffer, out payloadLength);`
`541`		`- } while (done == HeaderWriteResult.BufferTooSmall);`
	`541`	`+ } while (done == HPackHeaderWriter.HeaderWriteResult.BufferTooSmall);`
`542`	`542`	`_headerEncodingBuffer.Advance(payloadLength);`
`543`	`543`	`FinishWritingHeaders(streamId, payloadLength, done);`
`544`	`544`	`}`
`@@ -554,7 +554,7 @@ private ValueTask<FlushResult> WriteDataAndTrailersAsync(Http2Stream stream, in`
`554`	`554`	`}`
`555`	`555`	`}`
`556`	`556`
`557`		`- private void SplitHeaderFramesToOutput(int streamId, HeaderWriteResult done, bool isFramePrepared)`
	`557`	`+ private void SplitHeaderFramesToOutput(int streamId, HPackHeaderWriter.HeaderWriteResult done, bool isFramePrepared)`
`558`	`558`	`{`
`559`	`559`	`var dataToFrame = _headerEncodingBuffer.WrittenSpan;`
`560`	`560`	`var shouldPrepareFrame = !isFramePrepared;`
`@@ -569,9 +569,9 @@ private void SplitHeaderFramesToOutput(int streamId, HeaderWriteResult done, boo`
`569`	`569`	`shouldPrepareFrame = true;`
`570`	`570`	`}`
`571`	`571`
`572`		`- var currentSize = dataToFrame.Length > _maxFrameSize ? _maxFrameSize : dataToFrame.Length;`
	`572`	`+ var currentSize = Math.Min(dataToFrame.Length, _maxFrameSize);`
`573`	`573`	`_outgoingFrame.PayloadLength = currentSize;`
`574`		`- if (done == HeaderWriteResult.Done && dataToFrame.Length == currentSize)`
	`574`	`+ if (done == HPackHeaderWriter.HeaderWriteResult.Done && dataToFrame.Length == currentSize)`
`575`	`575`	`{`
`576`	`576`	`_outgoingFrame.HeadersFlags \|= Http2HeadersFrameFlags.END_HEADERS;`
`577`	`577`	`}`
`@@ -582,13 +582,13 @@ private void SplitHeaderFramesToOutput(int streamId, HeaderWriteResult done, boo`
`582`	`582`	`}`
`583`	`583`	`}`
`584`	`584`
`585`		`- private void FinishWritingHeaders(int streamId, int payloadLength, HeaderWriteResult done)`
	`585`	`+ private void FinishWritingHeaders(int streamId, int payloadLength, HPackHeaderWriter.HeaderWriteResult done)`
`586`	`586`	`{`
`587`	`587`	`SplitHeaderFramesToOutput(streamId, done, isFramePrepared: true);`
`588`		`- while (done != HeaderWriteResult.Done)`
	`588`	`+ while (done != HPackHeaderWriter.HeaderWriteResult.Done)`
`589`	`589`	`{`
`590`	`590`	`_headerEncodingBuffer.ResetWrittenCount();`
`591`		`- var bufferSize = done == HeaderWriteResult.BufferTooSmall ? _headerEncodingBuffer.Capacity * 2 : _headerEncodingBuffer.Capacity;`
	`591`	`+ var bufferSize = done == HPackHeaderWriter.HeaderWriteResult.BufferTooSmall ? _headerEncodingBuffer.Capacity * 2 : _headerEncodingBuffer.Capacity;`
`592`	`592`	`var buffer = _headerEncodingBuffer.GetSpan(bufferSize)[0..bufferSize];`
`593`	`593`	`done = HPackHeaderWriter.ContinueEncodeHeaders(_hpackEncoder, _headersEnumerator, buffer, out payloadLength);`
`594`	`594`	`_headerEncodingBuffer.Advance(payloadLength);`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public static void WriteStartStream(this PipeWriter writer, int streamId, Dynami`
`36`	`36`	`var done = HPackHeaderWriter.BeginEncodeHeaders(hpackEncoder, headers, buffer, out var length);`
`37`	`37`	`frame.PayloadLength = length;`
`38`	`38`
`39`		`- if (done == Microsoft.AspNetCore.Server.Kestrel.Core.Tests.HeaderWriteResult.Done)`
	`39`	`+ if (done == HPackHeaderWriter.HeaderWriteResult.Done)`
`40`	`40`	`{`
`41`	`41`	`frame.HeadersFlags = Http2HeadersFrameFlags.END_HEADERS;`
`42`	`42`	`}`
`@@ -49,14 +49,14 @@ public static void WriteStartStream(this PipeWriter writer, int streamId, Dynami`
`49`	`49`	`Http2FrameWriter.WriteHeader(frame, writer);`
`50`	`50`	`writer.Write(buffer.Slice(0, length));`
`51`	`51`
`52`		`- while (done != Microsoft.AspNetCore.Server.Kestrel.Core.Tests.HeaderWriteResult.Done)`
	`52`	`+ while (done != HPackHeaderWriter.HeaderWriteResult.Done)`
`53`	`53`	`{`
`54`	`54`	`frame.PrepareContinuation(Http2ContinuationFrameFlags.NONE, streamId);`
`55`	`55`
`56`	`56`	`done = HPackHeaderWriter.ContinueEncodeHeaders(hpackEncoder, headers, buffer, out length);`
`57`	`57`	`frame.PayloadLength = length;`
`58`	`58`
`59`		`- if (done == Microsoft.AspNetCore.Server.Kestrel.Core.Tests.HeaderWriteResult.Done)`
	`59`	`+ if (done == HPackHeaderWriter.HeaderWriteResult.Done)`
`60`	`60`	`{`
`61`	`61`	`frame.ContinuationFlags = Http2ContinuationFrameFlags.END_HEADERS;`
`62`	`62`	`}`