Stop doing sync over async in Produce100Continue (#31650)

wtgodbe · web-flow · commit 686da2e6c5b6 · 2021-04-13T15:27:45.000-07:00
* Stop doing sync over async in Produce100Continue

* Address feedback

* IsCompleted -&gt; IsCompletedSuccessfully

* Remove unneeded awaited methods

* Feedback

* Brain fart

* Update Http1ChunkedEncodingMessageBody.cs

* Update Http2MessageBody.cs

* Update Http2MessageBody.cs

* Update Http1ContentLengthMessageBody.cs

* Respond to feedback

* Quarantine failling test
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/Http1ChunkedEncodingMessageBody.cs b/src/Servers/Kestrel/Core/src/Internal/Http/Http1ChunkedEncodingMessageBody.cs
@@ -44,7 +44,7 @@ public override void AdvanceTo(SequencePosition consumed, SequencePosition exami
 
         public override bool TryReadInternal(out ReadResult readResult)
         {
-            TryStart();
+            TryStartAsync();
 
             var boolResult = _requestBodyPipe.Reader.TryRead(out _readResult);
 
@@ -61,7 +61,7 @@ public override bool TryReadInternal(out ReadResult readResult)
 
         public override async ValueTask<ReadResult> ReadAsyncInternal(CancellationToken cancellationToken = default)
         {
-            TryStart();
+            await TryStartAsync();
 
             try
             {
@@ -101,7 +101,7 @@ private async Task PumpAsync()
 
                 if (!awaitable.IsCompleted)
                 {
-                    TryProduceContinue();
+                    await TryProduceContinueAsync();
                 }
 
                 while (true)
@@ -171,7 +171,7 @@ protected override ValueTask OnStopAsync()
             // call complete here on the reader
             _requestBodyPipe.Reader.Complete();
 
-            Debug.Assert(_pumpTask != null, "OnReadStarted must have been called.");
+            Debug.Assert(_pumpTask != null, "OnReadStartedAsync must have been called.");
 
             // PumpTask catches all Exceptions internally.
             if (_pumpTask.IsCompleted)
@@ -195,9 +195,10 @@ private async ValueTask StopAsyncAwaited(Task pumpTask)
             _requestBodyPipe.Reset();
         }
 
-        protected override void OnReadStarted()
+        protected override Task OnReadStartedAsync()
         {
             _pumpTask = PumpAsync();
+            return Task.CompletedTask;
         }
 
         private bool Read(ReadOnlySequence<byte> readableBuffer, PipeWriter writableBuffer, out SequencePosition consumed, out SequencePosition examined)
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/Http1ContentLengthMessageBody.cs b/src/Servers/Kestrel/Core/src/Internal/Http/Http1ContentLengthMessageBody.cs
@@ -45,7 +45,7 @@ public override async ValueTask<ReadResult> ReadAsyncInternal(CancellationToken
                 KestrelBadHttpRequestException.Throw(RequestRejectionReason.RequestBodyTimeout);
             }
 
-            TryStart();
+            await TryStartAsync();
 
             // The while(true) loop is required because the Http1 connection calls CancelPendingRead to unblock
             // the call to StartTimingReadAsync to check if the request timed out.
@@ -132,7 +132,7 @@ public override bool TryReadInternal(out ReadResult readResult)
                 KestrelBadHttpRequestException.Throw(RequestRejectionReason.RequestBodyTimeout);
             }
 
-            TryStart();
+            TryStartAsync();
 
             // The while(true) because we don't want to return a canceled ReadResult if the user themselves didn't cancel it.
             while (true)
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.cs b/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.cs
@@ -909,27 +909,21 @@ protected bool VerifyResponseContentLength([NotNullWhen(false)] out Exception? e
             return true;
         }
 
-        public void ProduceContinue()
+        public ValueTask<FlushResult> ProduceContinueAsync()
         {
             if (HasResponseStarted)
             {
-                return;
+                return default;
             }
 
             if (_httpVersion != Http.HttpVersion.Http10 &&
                 ((IHeaderDictionary)HttpRequestHeaders).TryGetValue(HeaderNames.Expect, out var expect) &&
                 (expect.FirstOrDefault() ?? "").Equals("100-continue", StringComparison.OrdinalIgnoreCase))
             {
-                ValueTask<FlushResult> vt = Output.Write100ContinueAsync();
-                if (vt.IsCompleted)
-                {
-                    vt.GetAwaiter().GetResult();
-                }
-                else
-                {
-                    vt.AsTask().GetAwaiter().GetResult();
-                }
+                return Output.Write100ContinueAsync();
             }
+
+            return default;
         }
 
         public Task InitializeResponseAsync(int firstWriteByteCount)
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/IHttpResponseControl.cs b/src/Servers/Kestrel/Core/src/Internal/Http/IHttpResponseControl.cs
@@ -10,7 +10,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http
 {
     internal interface IHttpResponseControl
     {
-        void ProduceContinue();
+        ValueTask<FlushResult> ProduceContinueAsync();
         Memory<byte> GetMemory(int sizeHint = 0);
         Span<byte> GetSpan(int sizeHint = 0);
         void Advance(int bytes);
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/MessageBody.cs b/src/Servers/Kestrel/Core/src/Internal/Http/MessageBody.cs
@@ -66,11 +66,21 @@ public virtual ValueTask CompleteAsync(Exception? exception)
 
         public virtual Task ConsumeAsync()
         {
-            TryStart();
+            Task startTask = TryStartAsync();
+            if (!startTask.IsCompletedSuccessfully)
+            {
+                return ConsumeAwaited(startTask);
+            }    
 
             return OnConsumeAsync();
         }
 
+        private async Task ConsumeAwaited(Task startTask)
+        {
+            await startTask;
+            await OnConsumeAsync();
+        }
+
         public virtual ValueTask StopAsync()
         {
             TryStop();
@@ -93,20 +103,22 @@ public virtual void Reset()
             _examinedUnconsumedBytes = 0;
         }
 
-        protected void TryProduceContinue()
+        protected ValueTask<FlushResult> TryProduceContinueAsync()
         {
             if (_send100Continue)
             {
-                _context.HttpResponseControl.ProduceContinue();
                 _send100Continue = false;
+                return _context.HttpResponseControl.ProduceContinueAsync();
             }
+
+            return default;
         }
 
-        protected void TryStart()
+        protected Task TryStartAsync()
         {
             if (_context.HasStartedConsumingRequestBody)
             {
-                return;
+                return Task.CompletedTask;
             }
 
             OnReadStarting();
@@ -128,7 +140,7 @@ protected void TryStart()
                 }
             }
 
-            OnReadStarted();
+            return OnReadStartedAsync();
         }
 
         protected void TryStop()
@@ -165,8 +177,9 @@ protected virtual void OnReadStarting()
         {
         }
 
-        protected virtual void OnReadStarted()
+        protected virtual Task OnReadStartedAsync()
         {
+            return Task.CompletedTask;
         }
 
         protected void AddAndCheckObservedBytes(long observedBytes)
@@ -183,7 +196,15 @@ protected ValueTask<ReadResult> StartTimingReadAsync(ValueTask<ReadResult> readA
         {
             if (!readAwaitable.IsCompleted)
             {
-                TryProduceContinue();
+                ValueTask<FlushResult> continueTask = TryProduceContinueAsync();
+                if (!continueTask.IsCompletedSuccessfully)
+                {
+                    return StartTimingReadAwaited(continueTask, readAwaitable, cancellationToken);
+                }
+                else
+                {
+                    continueTask.GetAwaiter().GetResult();
+                }
 
                 if (_timingEnabled)
                 {
@@ -195,6 +216,19 @@ protected ValueTask<ReadResult> StartTimingReadAsync(ValueTask<ReadResult> readA
             return readAwaitable;
         }
 
+        protected async ValueTask<ReadResult> StartTimingReadAwaited(ValueTask<FlushResult> continueTask, ValueTask<ReadResult> readAwaitable, CancellationToken cancellationToken)
+        {
+            await continueTask;
+
+            if (_timingEnabled)
+            {
+                _backpressure = true;
+                _context.TimeoutControl.StartTimingRead();
+            }
+
+            return await readAwaitable;
+        }
+
         protected void CountBytesRead(long bytesInReadResult)
         {
             var numFirstSeenBytes = bytesInReadResult - _alreadyTimedBytes;
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http2/Http2MessageBody.cs b/src/Servers/Kestrel/Core/src/Internal/Http2/Http2MessageBody.cs
@@ -2,10 +2,12 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Diagnostics;
 using System.IO.Pipelines;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Connections;
+using Microsoft.AspNetCore.Internal;
 using Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http;
 
 namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2
@@ -30,13 +32,19 @@ protected override void OnReadStarting()
             }
         }
 
-        protected override void OnReadStarted()
+        protected override Task OnReadStartedAsync()
         {
             // Produce 100-continue if no request body data for the stream has arrived yet.
             if (!_context.RequestBodyStarted)
             {
-                TryProduceContinue();
+                ValueTask<FlushResult> continueTask = TryProduceContinueAsync();
+                if (!continueTask.IsCompletedSuccessfully)
+                {
+                    return continueTask.GetAsTask();
+                }
             }
+
+            return Task.CompletedTask;
         }
 
         public override void Reset()
@@ -59,7 +67,7 @@ public override void AdvanceTo(SequencePosition consumed, SequencePosition exami
 
         public override bool TryRead(out ReadResult readResult)
         {
-            TryStart();
+            TryStartAsync();
 
             var hasResult = _context.RequestBodyPipe.Reader.TryRead(out readResult);
 
@@ -80,7 +88,7 @@ public override bool TryRead(out ReadResult readResult)
 
         public override async ValueTask<ReadResult> ReadAsync(CancellationToken cancellationToken = default)
         {
-            TryStart();
+            await TryStartAsync();
 
             try
             {
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3MessageBody.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3MessageBody.cs
@@ -46,7 +46,7 @@ public override void AdvanceTo(SequencePosition consumed, SequencePosition exami
 
         public override bool TryRead(out ReadResult readResult)
         {
-            TryStart();
+            TryStartAsync();
 
             var hasResult = _context.RequestBodyPipe.Reader.TryRead(out readResult);
 
@@ -67,7 +67,7 @@ public override bool TryRead(out ReadResult readResult)
 
         public override async ValueTask<ReadResult> ReadAsync(CancellationToken cancellationToken = default)
         {
-            TryStart();
+            await TryStartAsync();
 
             try
             {
diff --git a/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3StreamTests.cs b/src/Servers/Kestrel/test/InMemory.FunctionalTests/Http3/Http3StreamTests.cs
@@ -628,6 +628,7 @@ public async Task RemoveConnectionSpecificHeaders()
         }
 
         [Fact]
+        [QuarantinedTest("https://github.com/dotnet/aspnetcore/issues/31777")]
         public async Task ContentLength_Received_NoDataFrames_Reset()
         {
             var headers = new[]

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public override void AdvanceTo(SequencePosition consumed, SequencePosition exami`
`44`	`44`
`45`	`45`	`public override bool TryReadInternal(out ReadResult readResult)`
`46`	`46`	`{`
`47`		`- TryStart();`
	`47`	`+ TryStartAsync();`
`48`	`48`
`49`	`49`	`var boolResult = _requestBodyPipe.Reader.TryRead(out _readResult);`
`50`	`50`
`@@ -61,7 +61,7 @@ public override bool TryReadInternal(out ReadResult readResult)`
`61`	`61`
`62`	`62`	`public override async ValueTask<ReadResult> ReadAsyncInternal(CancellationToken cancellationToken = default)`
`63`	`63`	`{`
`64`		`- TryStart();`
	`64`	`+ await TryStartAsync();`
`65`	`65`
`66`	`66`	`try`
`67`	`67`	`{`
`@@ -101,7 +101,7 @@ private async Task PumpAsync()`
`101`	`101`
`102`	`102`	`if (!awaitable.IsCompleted)`
`103`	`103`	`{`
`104`		`- TryProduceContinue();`
	`104`	`+ await TryProduceContinueAsync();`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`while (true)`
`@@ -171,7 +171,7 @@ protected override ValueTask OnStopAsync()`
`171`	`171`	`// call complete here on the reader`
`172`	`172`	`_requestBodyPipe.Reader.Complete();`
`173`	`173`
`174`		`- Debug.Assert(_pumpTask != null, "OnReadStarted must have been called.");`
	`174`	`+ Debug.Assert(_pumpTask != null, "OnReadStartedAsync must have been called.");`
`175`	`175`
`176`	`176`	`// PumpTask catches all Exceptions internally.`
`177`	`177`	`if (_pumpTask.IsCompleted)`
`@@ -195,9 +195,10 @@ private async ValueTask StopAsyncAwaited(Task pumpTask)`
`195`	`195`	`_requestBodyPipe.Reset();`
`196`	`196`	`}`
`197`	`197`
`198`		`- protected override void OnReadStarted()`
	`198`	`+ protected override Task OnReadStartedAsync()`
`199`	`199`	`{`
`200`	`200`	`_pumpTask = PumpAsync();`
	`201`	`+ return Task.CompletedTask;`
`201`	`202`	`}`
`202`	`203`
`203`	`204`	`private bool Read(ReadOnlySequence<byte> readableBuffer, PipeWriter writableBuffer, out SequencePosition consumed, out SequencePosition examined)`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public override async ValueTask<ReadResult> ReadAsyncInternal(CancellationToken`
`45`	`45`	`KestrelBadHttpRequestException.Throw(RequestRejectionReason.RequestBodyTimeout);`
`46`	`46`	`}`
`47`	`47`
`48`		`- TryStart();`
	`48`	`+ await TryStartAsync();`
`49`	`49`
`50`	`50`	`// The while(true) loop is required because the Http1 connection calls CancelPendingRead to unblock`
`51`	`51`	`// the call to StartTimingReadAsync to check if the request timed out.`
`@@ -132,7 +132,7 @@ public override bool TryReadInternal(out ReadResult readResult)`
`132`	`132`	`KestrelBadHttpRequestException.Throw(RequestRejectionReason.RequestBodyTimeout);`
`133`	`133`	`}`
`134`	`134`
`135`		`- TryStart();`
	`135`	`+ TryStartAsync();`
`136`	`136`
`137`	`137`	`// The while(true) because we don't want to return a canceled ReadResult if the user themselves didn't cancel it.`
`138`	`138`	`while (true)`
Original file line number	Diff line number	Diff line change
`@@ -909,27 +909,21 @@ protected bool VerifyResponseContentLength([NotNullWhen(false)] out Exception? e`
`909`	`909`	`return true;`
`910`	`910`	`}`
`911`	`911`
`912`		`- public void ProduceContinue()`
	`912`	`+ public ValueTask<FlushResult> ProduceContinueAsync()`
`913`	`913`	`{`
`914`	`914`	`if (HasResponseStarted)`
`915`	`915`	`{`
`916`		`- return;`
	`916`	`+ return default;`
`917`	`917`	`}`
`918`	`918`
`919`	`919`	`if (_httpVersion != Http.HttpVersion.Http10 &&`
`920`	`920`	`((IHeaderDictionary)HttpRequestHeaders).TryGetValue(HeaderNames.Expect, out var expect) &&`
`921`	`921`	`(expect.FirstOrDefault() ?? "").Equals("100-continue", StringComparison.OrdinalIgnoreCase))`
`922`	`922`	`{`
`923`		`- ValueTask<FlushResult> vt = Output.Write100ContinueAsync();`
`924`		`- if (vt.IsCompleted)`
`925`		`- {`
`926`		`- vt.GetAwaiter().GetResult();`
`927`		`- }`
`928`		`- else`
`929`		`- {`
`930`		`- vt.AsTask().GetAwaiter().GetResult();`
`931`		`- }`
	`923`	`+ return Output.Write100ContinueAsync();`
`932`	`924`	`}`
	`925`	`+`
	`926`	`+ return default;`
`933`	`927`	`}`
`934`	`928`
`935`	`929`	`public Task InitializeResponseAsync(int firstWriteByteCount)`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http`
`10`	`10`	`{`
`11`	`11`	`internal interface IHttpResponseControl`
`12`	`12`	`{`
`13`		`- void ProduceContinue();`
	`13`	`+ ValueTask<FlushResult> ProduceContinueAsync();`
`14`	`14`	`Memory<byte> GetMemory(int sizeHint = 0);`
`15`	`15`	`Span<byte> GetSpan(int sizeHint = 0);`
`16`	`16`	`void Advance(int bytes);`
Original file line number	Diff line number	Diff line change
`@@ -66,11 +66,21 @@ public virtual ValueTask CompleteAsync(Exception? exception)`
`66`	`66`
`67`	`67`	`public virtual Task ConsumeAsync()`
`68`	`68`	`{`
`69`		`- TryStart();`
	`69`	`+ Task startTask = TryStartAsync();`
	`70`	`+ if (!startTask.IsCompletedSuccessfully)`
	`71`	`+ {`
	`72`	`+ return ConsumeAwaited(startTask);`
	`73`	`+ }`
`70`	`74`
`71`	`75`	`return OnConsumeAsync();`
`72`	`76`	`}`
`73`	`77`
	`78`	`+ private async Task ConsumeAwaited(Task startTask)`
	`79`	`+ {`
	`80`	`+ await startTask;`
	`81`	`+ await OnConsumeAsync();`
	`82`	`+ }`
	`83`	`+`
`74`	`84`	`public virtual ValueTask StopAsync()`
`75`	`85`	`{`
`76`	`86`	`TryStop();`
`@@ -93,20 +103,22 @@ public virtual void Reset()`
`93`	`103`	`_examinedUnconsumedBytes = 0;`
`94`	`104`	`}`
`95`	`105`
`96`		`- protected void TryProduceContinue()`
	`106`	`+ protected ValueTask<FlushResult> TryProduceContinueAsync()`
`97`	`107`	`{`
`98`	`108`	`if (_send100Continue)`
`99`	`109`	`{`
`100`		`- _context.HttpResponseControl.ProduceContinue();`
`101`	`110`	`_send100Continue = false;`
	`111`	`+ return _context.HttpResponseControl.ProduceContinueAsync();`
`102`	`112`	`}`
	`113`	`+`
	`114`	`+ return default;`
`103`	`115`	`}`
`104`	`116`
`105`		`- protected void TryStart()`
	`117`	`+ protected Task TryStartAsync()`
`106`	`118`	`{`
`107`	`119`	`if (_context.HasStartedConsumingRequestBody)`
`108`	`120`	`{`
`109`		`- return;`
	`121`	`+ return Task.CompletedTask;`
`110`	`122`	`}`
`111`	`123`
`112`	`124`	`OnReadStarting();`
`@@ -128,7 +140,7 @@ protected void TryStart()`
`128`	`140`	`}`
`129`	`141`	`}`
`130`	`142`
`131`		`- OnReadStarted();`
	`143`	`+ return OnReadStartedAsync();`
`132`	`144`	`}`
`133`	`145`
`134`	`146`	`protected void TryStop()`
`@@ -165,8 +177,9 @@ protected virtual void OnReadStarting()`
`165`	`177`	`{`
`166`	`178`	`}`
`167`	`179`
`168`		`- protected virtual void OnReadStarted()`
	`180`	`+ protected virtual Task OnReadStartedAsync()`
`169`	`181`	`{`
	`182`	`+ return Task.CompletedTask;`
`170`	`183`	`}`
`171`	`184`
`172`	`185`	`protected void AddAndCheckObservedBytes(long observedBytes)`
`@@ -183,7 +196,15 @@ protected ValueTask<ReadResult> StartTimingReadAsync(ValueTask<ReadResult> readA`
`183`	`196`	`{`
`184`	`197`	`if (!readAwaitable.IsCompleted)`
`185`	`198`	`{`
`186`		`- TryProduceContinue();`
	`199`	`+ ValueTask<FlushResult> continueTask = TryProduceContinueAsync();`
	`200`	`+ if (!continueTask.IsCompletedSuccessfully)`
	`201`	`+ {`
	`202`	`+ return StartTimingReadAwaited(continueTask, readAwaitable, cancellationToken);`
	`203`	`+ }`
	`204`	`+ else`
	`205`	`+ {`
	`206`	`+ continueTask.GetAwaiter().GetResult();`
	`207`	`+ }`
`187`	`208`
`188`	`209`	`if (_timingEnabled)`
`189`	`210`	`{`
`@@ -195,6 +216,19 @@ protected ValueTask<ReadResult> StartTimingReadAsync(ValueTask<ReadResult> readA`
`195`	`216`	`return readAwaitable;`
`196`	`217`	`}`
`197`	`218`
	`219`	`+ protected async ValueTask<ReadResult> StartTimingReadAwaited(ValueTask<FlushResult> continueTask, ValueTask<ReadResult> readAwaitable, CancellationToken cancellationToken)`
	`220`	`+ {`
	`221`	`+ await continueTask;`
	`222`	`+`
	`223`	`+ if (_timingEnabled)`
	`224`	`+ {`
	`225`	`+ _backpressure = true;`
	`226`	`+ _context.TimeoutControl.StartTimingRead();`
	`227`	`+ }`
	`228`	`+`
	`229`	`+ return await readAwaitable;`
	`230`	`+ }`
	`231`	`+`
`198`	`232`	`protected void CountBytesRead(long bytesInReadResult)`
`199`	`233`	`{`
`200`	`234`	`var numFirstSeenBytes = bytesInReadResult - _alreadyTimedBytes;`
Original file line number	Diff line number	Diff line change
`@@ -2,10 +2,12 @@`
`2`	`2`	`// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.`
`3`	`3`
`4`	`4`	`using System;`
	`5`	`+using System.Diagnostics;`
`5`	`6`	`using System.IO.Pipelines;`
`6`	`7`	`using System.Threading;`
`7`	`8`	`using System.Threading.Tasks;`
`8`	`9`	`using Microsoft.AspNetCore.Connections;`
	`10`	`+using Microsoft.AspNetCore.Internal;`
`9`	`11`	`using Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http;`
`10`	`12`
`11`	`13`	`namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2`
`@@ -30,13 +32,19 @@ protected override void OnReadStarting()`
`30`	`32`	`}`
`31`	`33`	`}`
`32`	`34`
`33`		`- protected override void OnReadStarted()`
	`35`	`+ protected override Task OnReadStartedAsync()`
`34`	`36`	`{`
`35`	`37`	`// Produce 100-continue if no request body data for the stream has arrived yet.`
`36`	`38`	`if (!_context.RequestBodyStarted)`
`37`	`39`	`{`
`38`		`- TryProduceContinue();`
	`40`	`+ ValueTask<FlushResult> continueTask = TryProduceContinueAsync();`
	`41`	`+ if (!continueTask.IsCompletedSuccessfully)`
	`42`	`+ {`
	`43`	`+ return continueTask.GetAsTask();`
	`44`	`+ }`
`39`	`45`	`}`
	`46`	`+`
	`47`	`+ return Task.CompletedTask;`
`40`	`48`	`}`
`41`	`49`
`42`	`50`	`public override void Reset()`
`@@ -59,7 +67,7 @@ public override void AdvanceTo(SequencePosition consumed, SequencePosition exami`
`59`	`67`
`60`	`68`	`public override bool TryRead(out ReadResult readResult)`
`61`	`69`	`{`
`62`		`- TryStart();`
	`70`	`+ TryStartAsync();`
`63`	`71`
`64`	`72`	`var hasResult = _context.RequestBodyPipe.Reader.TryRead(out readResult);`
`65`	`73`
`@@ -80,7 +88,7 @@ public override bool TryRead(out ReadResult readResult)`
`80`	`88`
`81`	`89`	`public override async ValueTask<ReadResult> ReadAsync(CancellationToken cancellationToken = default)`
`82`	`90`	`{`
`83`		`- TryStart();`
	`91`	`+ await TryStartAsync();`
`84`	`92`
`85`	`93`	`try`
`86`	`94`	`{`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public override void AdvanceTo(SequencePosition consumed, SequencePosition exami`
`46`	`46`
`47`	`47`	`public override bool TryRead(out ReadResult readResult)`
`48`	`48`	`{`
`49`		`- TryStart();`
	`49`	`+ TryStartAsync();`
`50`	`50`
`51`	`51`	`var hasResult = _context.RequestBodyPipe.Reader.TryRead(out readResult);`
`52`	`52`
`@@ -67,7 +67,7 @@ public override bool TryRead(out ReadResult readResult)`
`67`	`67`
`68`	`68`	`public override async ValueTask<ReadResult> ReadAsync(CancellationToken cancellationToken = default)`
`69`	`69`	`{`
`70`		`- TryStart();`
	`70`	`+ await TryStartAsync();`
`71`	`71`
`72`	`72`	`try`
`73`	`73`	`{`
Original file line number	Diff line number	Diff line change
`@@ -628,6 +628,7 @@ public async Task RemoveConnectionSpecificHeaders()`
`628`	`628`	`}`
`629`	`629`
`630`	`630`	`[Fact]`
	`631`	`+ [QuarantinedTest("https://github.com/dotnet/aspnetcore/issues/31777")]`
`631`	`632`	`public async Task ContentLength_Received_NoDataFrames_Reset()`
`632`	`633`	`{`
`633`	`634`	`var headers = new[]`