Get rid of StreamWriter usage in HTTP loopback server and fix HTTP/1.1 loopback implementation of SendResponseBodyAsync (#47364)

geoffkizer · Geoffrey Kizer · web-flow · commit 59417ef2d756 · 2021-01-25T16:30:29.000-08:00
Get rid of StreamWriter usage in HTTP loopback server and fix HTTP/1.1 loopback implementation of SendResponseBodyAsync 

Co-authored-by: Geoffrey Kizer &lt;geoffrek@windows.microsoft.com&gt;
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Asynchrony.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Asynchrony.cs
@@ -59,7 +59,7 @@ await LoopbackServer.CreateClientAndServerAsync(uri =>
                     await server.AcceptConnectionAsync(async connection =>
                     {
                         await connection.ReadRequestHeaderAsync();
-                        await connection.Writer.WriteAsync(
+                        await connection.WriteStringAsync(
                             LoopbackServer.GetContentModeResponse(
                                 contentMode,
                                 string.Concat(Enumerable.Repeat('s', 10_000)),
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cancellation.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cancellation.cs
@@ -351,10 +351,10 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
                     Task serverTask1 = server.AcceptConnectionAsync(async connection1 =>
                     {
                         await connection1.ReadRequestHeaderAsync();
-                        await connection1.Writer.WriteAsync($"HTTP/1.1 200 OK\r\nConnection: close\r\nDate: {DateTimeOffset.UtcNow:R}\r\n");
+                        await connection1.WriteStringAsync($"HTTP/1.1 200 OK\r\nConnection: close\r\nDate: {DateTimeOffset.UtcNow:R}\r\n");
                         serverAboutToBlock.SetResult(true);
                         await blockServerResponse.Task;
-                        await connection1.Writer.WriteAsync("Content-Length: 5\r\n\r\nhello");
+                        await connection1.WriteStringAsync("Content-Length: 5\r\n\r\nhello");
                     });
 
                     Task get1 = client.GetAsync(url);
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Decompression.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Decompression.cs
@@ -101,7 +101,7 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
                 await server.AcceptConnectionAsync(async connection =>
                 {
                     await connection.ReadRequestHeaderAsync();
-                    await connection.Writer.WriteAsync($"HTTP/1.1 200 OK\r\nContent-Encoding: {encodingName}\r\n\r\n");
+                    await connection.WriteStringAsync($"HTTP/1.1 200 OK\r\nContent-Encoding: {encodingName}\r\n\r\n");
                     using (Stream compressedStream = compress(connection.Stream))
                     {
                         await compressedStream.WriteAsync(expectedContent);
@@ -163,7 +163,7 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>
                 await server.AcceptConnectionAsync(async connection =>
                 {
                     await connection.ReadRequestHeaderAsync();
-                    await connection.Writer.WriteAsync($"HTTP/1.1 200 OK\r\nContent-Encoding: {encodingName}\r\n\r\n");
+                    await connection.WriteStringAsync($"HTTP/1.1 200 OK\r\nContent-Encoding: {encodingName}\r\n\r\n");
                     await connection.Stream.WriteAsync(compressedContent);
                 });
             });
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.MaxResponseHeadersLength.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.MaxResponseHeadersLength.cs
@@ -86,7 +86,7 @@ await server.AcceptConnectionAsync(async connection =>
                             {
                                 while (!cts.IsCancellationRequested)
                                 {
-                                    await connection.Writer.WriteAsync(new string('s', 16000));
+                                    await connection.WriteStringAsync(new string('s', 16000));
                                     await Task.Delay(1);
                                 }
                             }
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.cs
@@ -969,12 +969,11 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>
                     Task serverTask = server.AcceptConnectionAsync(async connection =>
                     {
                         await connection.ReadRequestHeaderAndSendCustomResponseAsync("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");
-                        TextWriter writer = connection.Writer;
                         try
                         {
                             while (!cts.IsCancellationRequested) // infinite to make sure implementation doesn't OOM
                             {
-                                await writer.WriteAsync(new string(' ', 10000));
+                                await connection.WriteStringAsync(new string(' ', 10000));
                                 await Task.Delay(1);
                             }
                         }
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpProtocolTests.cs b/src/libraries/Common/tests/System/Net/Http/HttpProtocolTests.cs
@@ -442,18 +442,18 @@ await server.AcceptConnectionAsync(async connection =>
                 {
                     await connection.ReadRequestHeaderAsync();
 
-                    await connection.Writer.WriteAsync($"HTTP/1.1 200 OK{lineEnding}Transfer-Encoding: chunked{lineEnding}{lineEnding}");
+                    await connection.WriteStringAsync($"HTTP/1.1 200 OK{lineEnding}Transfer-Encoding: chunked{lineEnding}{lineEnding}");
                     for (int bytesSent = 0; bytesSent < expectedData.Length;)
                     {
                         int bytesRemaining = expectedData.Length - bytesSent;
                         int bytesToSend = rand.Next(1, Math.Min(bytesRemaining, maxChunkSize + 1));
-                        await connection.Writer.WriteAsync(bytesToSend.ToString("X") + lineEnding);
+                        await connection.WriteStringAsync(bytesToSend.ToString("X") + lineEnding);
                         await connection.Stream.WriteAsync(new Memory<byte>(expectedData, bytesSent, bytesToSend));
-                        await connection.Writer.WriteAsync(lineEnding);
+                        await connection.WriteStringAsync(lineEnding);
                         bytesSent += bytesToSend;
                     }
-                    await connection.Writer.WriteAsync($"0{lineEnding}");
-                    await connection.Writer.WriteAsync(lineEnding);
+                    await connection.WriteStringAsync($"0{lineEnding}");
+                    await connection.WriteStringAsync(lineEnding);
                 });
             });
         }
diff --git a/src/libraries/Common/tests/System/Net/Http/LoopbackServer.cs b/src/libraries/Common/tests/System/Net/Http/LoopbackServer.cs
@@ -397,7 +397,6 @@ public sealed class Connection : GenericLoopbackConnection
             private const int BufferSize = 4000;
             private Socket _socket;
             private Stream _stream;
-            private StreamWriter _writer;
             private byte[] _readBuffer;
             private int _readStart;
             private int _readEnd;
@@ -409,16 +408,13 @@ public Connection(Socket socket, Stream stream)
                 _socket = socket;
                 _stream = stream;
 
-                _writer = new StreamWriter(stream, Encoding.ASCII) { AutoFlush = true };
-
                 _readBuffer = new byte[BufferSize];
                 _readStart = 0;
                 _readEnd = 0;
             }
 
             public Socket Socket => _socket;
             public Stream Stream => _stream;
-            public StreamWriter Writer => _writer;
 
             public static async Task<Connection> CreateAsync(Socket socket, Stream stream, Options httpOptions)
             {
@@ -620,7 +616,6 @@ public override void Dispose()
                 }
                 catch (Exception) { }
 
-                _writer.Dispose();
                 _stream.Dispose();
                 _socket?.Dispose();
             }
@@ -673,9 +668,20 @@ private async Task<List<byte[]>> ReadRequestHeaderBytesAsync()
                 return lines;
             }
 
+            public async Task WriteStringAsync(string s)
+            {
+                byte[] bytes = Encoding.ASCII.GetBytes(s);
+                await _stream.WriteAsync(bytes);
+            }
+
             public async Task SendResponseAsync(string response)
             {
-                await _writer.WriteAsync(response).ConfigureAwait(false);
+                await WriteStringAsync(response);
+            }
+
+            public async Task SendResponseAsync(byte[] response)
+            {
+                await _stream.WriteAsync(response);
             }
 
             public async Task SendResponseAsync(HttpStatusCode statusCode = HttpStatusCode.OK, string additionalHeaders = null, string content = null)
@@ -686,7 +692,7 @@ public async Task SendResponseAsync(HttpStatusCode statusCode = HttpStatusCode.O
             public async Task<List<string>> ReadRequestHeaderAndSendCustomResponseAsync(string response)
             {
                 List<string> lines = await ReadRequestHeaderAsync().ConfigureAwait(false);
-                await _writer.WriteAsync(response).ConfigureAwait(false);
+                await WriteStringAsync(response);
                 return lines;
             }
 
@@ -892,7 +898,7 @@ public override async Task SendResponseHeadersAsync(HttpStatusCode statusCode =
 
             public override async Task SendResponseBodyAsync(byte[] body, bool isFinal = true, int requestId = 0)
             {
-                await SendResponseAsync(Encoding.UTF8.GetString(body)).ConfigureAwait(false);
+                await SendResponseAsync(body).ConfigureAwait(false);
             }
 
             public override async Task<HttpRequestData> HandleRequestAsync(HttpStatusCode statusCode = HttpStatusCode.OK, IList<HttpHeaderData> headers = null, string content = "")
diff --git a/src/libraries/Common/tests/System/Net/Http/ResponseStreamTest.cs b/src/libraries/Common/tests/System/Net/Http/ResponseStreamTest.cs
@@ -321,32 +321,31 @@ public static Task StartTransferTypeAndErrorServer(
                     }
 
                     // Write response header
-                    TextWriter writer = connection.Writer;
-                    await writer.WriteAsync("HTTP/1.1 200 OK\r\n").ConfigureAwait(false);
-                    await writer.WriteAsync($"Date: {DateTimeOffset.UtcNow:R}\r\n").ConfigureAwait(false);
-                    await writer.WriteAsync("Content-Type: text/plain\r\n").ConfigureAwait(false);
+                    await connection.WriteStringAsync("HTTP/1.1 200 OK\r\n").ConfigureAwait(false);
+                    await connection.WriteStringAsync($"Date: {DateTimeOffset.UtcNow:R}\r\n").ConfigureAwait(false);
+                    await connection.WriteStringAsync("Content-Type: text/plain\r\n").ConfigureAwait(false);
                     if (!string.IsNullOrEmpty(transferHeader))
                     {
-                        await writer.WriteAsync(transferHeader).ConfigureAwait(false);
+                        await connection.WriteStringAsync(transferHeader).ConfigureAwait(false);
                     }
-                    await writer.WriteAsync("\r\n").ConfigureAwait(false);
+                    await connection.WriteStringAsync("\r\n").ConfigureAwait(false);
 
                     // Write response body
                     if (transferType == TransferType.Chunked)
                     {
                         string chunkSizeInHex = string.Format(
                             "{0:x}\r\n",
                             content.Length + (transferError == TransferError.ChunkSizeTooLarge ? 42 : 0));
-                        await writer.WriteAsync(chunkSizeInHex).ConfigureAwait(false);
-                        await writer.WriteAsync($"{content}\r\n").ConfigureAwait(false);
+                        await connection.WriteStringAsync(chunkSizeInHex).ConfigureAwait(false);
+                        await connection.WriteStringAsync($"{content}\r\n").ConfigureAwait(false);
                         if (transferError != TransferError.MissingChunkTerminator)
                         {
-                            await writer.WriteAsync("0\r\n\r\n").ConfigureAwait(false);
+                            await connection.WriteStringAsync("0\r\n\r\n").ConfigureAwait(false);
                         }
                     }
                     else
                     {
-                        await writer.WriteAsync($"{content}").ConfigureAwait(false);
+                        await connection.WriteStringAsync($"{content}").ConfigureAwait(false);
                     }
                 }));
         }
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Connect.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Connect.cs
@@ -52,7 +52,7 @@ await server.AcceptConnectionAsync(async connection =>
 
                             TextReader clientReader = new StreamReader(clientStream);
                             TextWriter clientWriter = new StreamWriter(clientStream) { AutoFlush = true };
-                            TextWriter serverWriter = connection.Writer;
+                            TextWriter serverWriter = new StreamWriter(connection.Stream, leaveOpen: true) { AutoFlush = true };
 
                             const string helloServer = "hello server";
                             const string helloClient = "hello client";
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Headers.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.Headers.cs
@@ -391,10 +391,16 @@ await LoopbackServerFactory.CreateClientAndServerAsync(
                 },
                 async server =>
                 {
-                    await server.HandleRequestAsync(headers: new[]
+                    // The client may detect the bad header and close the connection before we are done sending the response.
+                    // So, eat any IOException that occurs here.
+                    try
                     {
-                        new HttpHeaderData("", "foo")
-                    });
+                        await server.HandleRequestAsync(headers: new[]
+                        {
+                            new HttpHeaderData("", "foo")
+                        });
+                    }
+                    catch (IOException) { }
                 });
         }
 
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.ResponseDrain.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientHandlerTest.ResponseDrain.cs
@@ -128,7 +128,7 @@ await server.AcceptConnectionAsync(async connection =>
                         await connection.ReadRequestHeaderAsync().ConfigureAwait(false);
                         foreach (char c in response)
                         {
-                            await connection.Writer.WriteAsync(c);
+                            await connection.WriteStringAsync(c.ToString());
                         }
 
                         // Process the second request.
@@ -197,7 +197,7 @@ await server.AcceptConnectionAsync(async connection =>
                         await connection.ReadRequestHeaderAsync();
                         try
                         {
-                            await connection.Writer.WriteAsync(LoopbackServer.GetContentModeResponse(mode, content, connectionClose: false));
+                            await connection.WriteStringAsync(LoopbackServer.GetContentModeResponse(mode, content, connectionClose: false));
                         }
                         catch (Exception) { }     // Eat errors from client disconnect.
 
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientMiniStressTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientMiniStressTest.cs
@@ -88,7 +88,7 @@ await server.AcceptConnectionAsync(async connection =>
                     while (!string.IsNullOrEmpty(await connection.ReadLineAsync().ConfigureAwait(false)));
                     Assert.Equal(numBytes, await connection.ReadBlockAsync(postData, 0, numBytes));
 
-                    await connection.Writer.WriteAsync(responseText).ConfigureAwait(false);
+                    await connection.WriteStringAsync(responseText).ConfigureAwait(false);
                     connection.Socket.Shutdown(SocketShutdown.Send);
                 });
 
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientTest.cs
@@ -1065,7 +1065,7 @@ await server.AcceptConnectionAsync(async connection =>
                             cts.Cancel();
                             for (int i = 0; i < 100; ++i)
                             {
-                                await connection.Writer.WriteLineAsync(content);
+                                await connection.WriteStringAsync(content);
                                 await Task.Delay(TimeSpan.FromSeconds(0.1));
                             }
                         }
@@ -1090,8 +1090,7 @@ public void Send_TimeoutResponseContent_Throws()
                 await connection.SendResponseAsync(headers: new[] { new HttpHeaderData("Content-Length", (Content.Length * 100).ToString()) });
                 for (int i = 0; i < 100; ++i)
                 {
-                    await connection.Writer.WriteLineAsync(Content);
-                    await connection.Writer.FlushAsync();
+                    await connection.WriteStringAsync(Content);
                     await Task.Delay(TimeSpan.FromSeconds(0.1));
                 }
             });
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs
@@ -408,7 +408,7 @@ await server.AcceptConnectionAsync(async connection =>
                         await connection.ReadRequestHeaderAsync();
                         try
                         {
-                            await connection.Writer.WriteAsync(LoopbackServer.GetContentModeResponse(mode, content, connectionClose: false));
+                            await connection.WriteStringAsync(LoopbackServer.GetContentModeResponse(mode, content, connectionClose: false));
                         }
                         catch (Exception) { }     // Eat errors from client disconnect.
 
@@ -460,7 +460,7 @@ await server.AcceptConnectionAsync(async connection =>
                         try
                         {
                             // Write out only part of the response
-                            await connection.Writer.WriteAsync(response.Substring(0, response.Length / 2));
+                            await connection.WriteStringAsync(response.Substring(0, response.Length / 2));
                         }
                         catch (Exception) { }     // Eat errors from client disconnect.
 
@@ -1324,7 +1324,7 @@ await LoopbackServer.CreateServerAsync(async (server, uri) =>
 
                     Task serverTask1 = server.AcceptConnectionAsync(async connection =>
                     {
-                        await connection.Writer.WriteAsync(LoopbackServer.GetHttpResponse(connectionClose: false) + "here is a bunch of garbage");
+                        await connection.WriteStringAsync(LoopbackServer.GetHttpResponse(connectionClose: false) + "here is a bunch of garbage");
                         await releaseServer.Task; // keep connection alive on the server side
                     });
                     await client.GetStringAsync(uri);
diff --git a/src/libraries/System.Net.WebSockets.Client/tests/LoopbackHelper.cs b/src/libraries/System.Net.WebSockets.Client/tests/LoopbackHelper.cs
@@ -42,7 +42,7 @@ public static async Task<Dictionary<string, string>> WebSocketHandshakeAsync(Loo
             if (serverResponse != null)
             {
                 // We received a valid WebSocket opening handshake. Send the appropriate response.
-                await connection.Writer.WriteAsync(serverResponse).ConfigureAwait(false);
+                await connection.WriteStringAsync(serverResponse).ConfigureAwait(false);
                 return results;
             }
 

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ await LoopbackServer.CreateClientAndServerAsync(uri =>`
`59`	`59`	`await server.AcceptConnectionAsync(async connection =>`
`60`	`60`	`{`
`61`	`61`	`await connection.ReadRequestHeaderAsync();`
`62`		`- await connection.Writer.WriteAsync(`
	`62`	`+ await connection.WriteStringAsync(`
`63`	`63`	`LoopbackServer.GetContentModeResponse(`
`64`	`64`	`contentMode,`
`65`	`65`	`string.Concat(Enumerable.Repeat('s', 10_000)),`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>`
`101`	`101`	`await server.AcceptConnectionAsync(async connection =>`
`102`	`102`	`{`
`103`	`103`	`await connection.ReadRequestHeaderAsync();`
`104`		`- await connection.Writer.WriteAsync($"HTTP/1.1 200 OK\r\nContent-Encoding: {encodingName}\r\n\r\n");`
	`104`	`+ await connection.WriteStringAsync($"HTTP/1.1 200 OK\r\nContent-Encoding: {encodingName}\r\n\r\n");`
`105`	`105`	`using (Stream compressedStream = compress(connection.Stream))`
`106`	`106`	`{`
`107`	`107`	`await compressedStream.WriteAsync(expectedContent);`
`@@ -163,7 +163,7 @@ await LoopbackServer.CreateClientAndServerAsync(async uri =>`
`163`	`163`	`await server.AcceptConnectionAsync(async connection =>`
`164`	`164`	`{`
`165`	`165`	`await connection.ReadRequestHeaderAsync();`
`166`		`- await connection.Writer.WriteAsync($"HTTP/1.1 200 OK\r\nContent-Encoding: {encodingName}\r\n\r\n");`
	`166`	`+ await connection.WriteStringAsync($"HTTP/1.1 200 OK\r\nContent-Encoding: {encodingName}\r\n\r\n");`
`167`	`167`	`await connection.Stream.WriteAsync(compressedContent);`
`168`	`168`	`});`
`169`	`169`	`});`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ await server.AcceptConnectionAsync(async connection =>`
`86`	`86`	`{`
`87`	`87`	`while (!cts.IsCancellationRequested)`
`88`	`88`	`{`
`89`		`- await connection.Writer.WriteAsync(new string('s', 16000));`
	`89`	`+ await connection.WriteStringAsync(new string('s', 16000));`
`90`	`90`	`await Task.Delay(1);`
`91`	`91`	`}`
`92`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -969,12 +969,11 @@ await LoopbackServer.CreateServerAsync(async (server, url) =>`
`969`	`969`	`Task serverTask = server.AcceptConnectionAsync(async connection =>`
`970`	`970`	`{`
`971`	`971`	`await connection.ReadRequestHeaderAndSendCustomResponseAsync("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");`
`972`		`- TextWriter writer = connection.Writer;`
`973`	`972`	`try`
`974`	`973`	`{`
`975`	`974`	`while (!cts.IsCancellationRequested) // infinite to make sure implementation doesn't OOM`
`976`	`975`	`{`
`977`		`- await writer.WriteAsync(new string(' ', 10000));`
	`976`	`+ await connection.WriteStringAsync(new string(' ', 10000));`
`978`	`977`	`await Task.Delay(1);`
`979`	`978`	`}`
`980`	`979`	`}`
Original file line number	Diff line number	Diff line change
`@@ -442,18 +442,18 @@ await server.AcceptConnectionAsync(async connection =>`
`442`	`442`	`{`
`443`	`443`	`await connection.ReadRequestHeaderAsync();`
`444`	`444`
`445`		`- await connection.Writer.WriteAsync($"HTTP/1.1 200 OK{lineEnding}Transfer-Encoding: chunked{lineEnding}{lineEnding}");`
	`445`	`+ await connection.WriteStringAsync($"HTTP/1.1 200 OK{lineEnding}Transfer-Encoding: chunked{lineEnding}{lineEnding}");`
`446`	`446`	`for (int bytesSent = 0; bytesSent < expectedData.Length;)`
`447`	`447`	`{`
`448`	`448`	`int bytesRemaining = expectedData.Length - bytesSent;`
`449`	`449`	`int bytesToSend = rand.Next(1, Math.Min(bytesRemaining, maxChunkSize + 1));`
`450`		`- await connection.Writer.WriteAsync(bytesToSend.ToString("X") + lineEnding);`
	`450`	`+ await connection.WriteStringAsync(bytesToSend.ToString("X") + lineEnding);`
`451`	`451`	`await connection.Stream.WriteAsync(new Memory<byte>(expectedData, bytesSent, bytesToSend));`
`452`		`- await connection.Writer.WriteAsync(lineEnding);`
	`452`	`+ await connection.WriteStringAsync(lineEnding);`
`453`	`453`	`bytesSent += bytesToSend;`
`454`	`454`	`}`
`455`		`- await connection.Writer.WriteAsync($"0{lineEnding}");`
`456`		`- await connection.Writer.WriteAsync(lineEnding);`
	`455`	`+ await connection.WriteStringAsync($"0{lineEnding}");`
	`456`	`+ await connection.WriteStringAsync(lineEnding);`
`457`	`457`	`});`
`458`	`458`	`});`
`459`	`459`	`}`
Original file line number	Diff line number	Diff line change
`@@ -397,7 +397,6 @@ public sealed class Connection : GenericLoopbackConnection`
`397`	`397`	`private const int BufferSize = 4000;`
`398`	`398`	`private Socket _socket;`
`399`	`399`	`private Stream _stream;`
`400`		`- private StreamWriter _writer;`
`401`	`400`	`private byte[] _readBuffer;`
`402`	`401`	`private int _readStart;`
`403`	`402`	`private int _readEnd;`
`@@ -409,16 +408,13 @@ public Connection(Socket socket, Stream stream)`
`409`	`408`	`_socket = socket;`
`410`	`409`	`_stream = stream;`
`411`	`410`
`412`		`- _writer = new StreamWriter(stream, Encoding.ASCII) { AutoFlush = true };`
`413`		`-`
`414`	`411`	`_readBuffer = new byte[BufferSize];`
`415`	`412`	`_readStart = 0;`
`416`	`413`	`_readEnd = 0;`
`417`	`414`	`}`
`418`	`415`
`419`	`416`	`public Socket Socket => _socket;`
`420`	`417`	`public Stream Stream => _stream;`
`421`		`- public StreamWriter Writer => _writer;`
`422`	`418`
`423`	`419`	`public static async Task<Connection> CreateAsync(Socket socket, Stream stream, Options httpOptions)`
`424`	`420`	`{`
`@@ -620,7 +616,6 @@ public override void Dispose()`
`620`	`616`	`}`
`621`	`617`	`catch (Exception) { }`
`622`	`618`
`623`		`- _writer.Dispose();`
`624`	`619`	`_stream.Dispose();`
`625`	`620`	`_socket?.Dispose();`
`626`	`621`	`}`
`@@ -673,9 +668,20 @@ private async Task<List<byte[]>> ReadRequestHeaderBytesAsync()`
`673`	`668`	`return lines;`
`674`	`669`	`}`
`675`	`670`
	`671`	`+ public async Task WriteStringAsync(string s)`
	`672`	`+ {`
	`673`	`+ byte[] bytes = Encoding.ASCII.GetBytes(s);`
	`674`	`+ await _stream.WriteAsync(bytes);`
	`675`	`+ }`
	`676`	`+`
`676`	`677`	`public async Task SendResponseAsync(string response)`
`677`	`678`	`{`
`678`		`- await _writer.WriteAsync(response).ConfigureAwait(false);`
	`679`	`+ await WriteStringAsync(response);`
	`680`	`+ }`
	`681`	`+`
	`682`	`+ public async Task SendResponseAsync(byte[] response)`
	`683`	`+ {`
	`684`	`+ await _stream.WriteAsync(response);`
`679`	`685`	`}`
`680`	`686`
`681`	`687`	`public async Task SendResponseAsync(HttpStatusCode statusCode = HttpStatusCode.OK, string additionalHeaders = null, string content = null)`
`@@ -686,7 +692,7 @@ public async Task SendResponseAsync(HttpStatusCode statusCode = HttpStatusCode.O`
`686`	`692`	`public async Task<List<string>> ReadRequestHeaderAndSendCustomResponseAsync(string response)`
`687`	`693`	`{`
`688`	`694`	`List<string> lines = await ReadRequestHeaderAsync().ConfigureAwait(false);`
`689`		`- await _writer.WriteAsync(response).ConfigureAwait(false);`
	`695`	`+ await WriteStringAsync(response);`
`690`	`696`	`return lines;`
`691`	`697`	`}`
`692`	`698`
`@@ -892,7 +898,7 @@ public override async Task SendResponseHeadersAsync(HttpStatusCode statusCode =`
`892`	`898`
`893`	`899`	`public override async Task SendResponseBodyAsync(byte[] body, bool isFinal = true, int requestId = 0)`
`894`	`900`	`{`
`895`		`- await SendResponseAsync(Encoding.UTF8.GetString(body)).ConfigureAwait(false);`
	`901`	`+ await SendResponseAsync(body).ConfigureAwait(false);`
`896`	`902`	`}`
`897`	`903`
`898`	`904`	`public override async Task<HttpRequestData> HandleRequestAsync(HttpStatusCode statusCode = HttpStatusCode.OK, IList<HttpHeaderData> headers = null, string content = "")`
Original file line number	Diff line number	Diff line change
`@@ -321,32 +321,31 @@ public static Task StartTransferTypeAndErrorServer(`
`321`	`321`	`}`
`322`	`322`
`323`	`323`	`// Write response header`
`324`		`- TextWriter writer = connection.Writer;`
`325`		`- await writer.WriteAsync("HTTP/1.1 200 OK\r\n").ConfigureAwait(false);`
`326`		`- await writer.WriteAsync($"Date: {DateTimeOffset.UtcNow:R}\r\n").ConfigureAwait(false);`
`327`		`- await writer.WriteAsync("Content-Type: text/plain\r\n").ConfigureAwait(false);`
	`324`	`+ await connection.WriteStringAsync("HTTP/1.1 200 OK\r\n").ConfigureAwait(false);`
	`325`	`+ await connection.WriteStringAsync($"Date: {DateTimeOffset.UtcNow:R}\r\n").ConfigureAwait(false);`
	`326`	`+ await connection.WriteStringAsync("Content-Type: text/plain\r\n").ConfigureAwait(false);`
`328`	`327`	`if (!string.IsNullOrEmpty(transferHeader))`
`329`	`328`	`{`
`330`		`- await writer.WriteAsync(transferHeader).ConfigureAwait(false);`
	`329`	`+ await connection.WriteStringAsync(transferHeader).ConfigureAwait(false);`
`331`	`330`	`}`
`332`		`- await writer.WriteAsync("\r\n").ConfigureAwait(false);`
	`331`	`+ await connection.WriteStringAsync("\r\n").ConfigureAwait(false);`
`333`	`332`
`334`	`333`	`// Write response body`
`335`	`334`	`if (transferType == TransferType.Chunked)`
`336`	`335`	`{`
`337`	`336`	`string chunkSizeInHex = string.Format(`
`338`	`337`	`"{0:x}\r\n",`
`339`	`338`	`content.Length + (transferError == TransferError.ChunkSizeTooLarge ? 42 : 0));`
`340`		`- await writer.WriteAsync(chunkSizeInHex).ConfigureAwait(false);`
`341`		`- await writer.WriteAsync($"{content}\r\n").ConfigureAwait(false);`
	`339`	`+ await connection.WriteStringAsync(chunkSizeInHex).ConfigureAwait(false);`
	`340`	`+ await connection.WriteStringAsync($"{content}\r\n").ConfigureAwait(false);`
`342`	`341`	`if (transferError != TransferError.MissingChunkTerminator)`
`343`	`342`	`{`
`344`		`- await writer.WriteAsync("0\r\n\r\n").ConfigureAwait(false);`
	`343`	`+ await connection.WriteStringAsync("0\r\n\r\n").ConfigureAwait(false);`
`345`	`344`	`}`
`346`	`345`	`}`
`347`	`346`	`else`
`348`	`347`	`{`
`349`		`- await writer.WriteAsync($"{content}").ConfigureAwait(false);`
	`348`	`+ await connection.WriteStringAsync($"{content}").ConfigureAwait(false);`
`350`	`349`	`}`
`351`	`350`	`}));`
`352`	`351`	`}`
Original file line number	Diff line number	Diff line change
`@@ -391,10 +391,16 @@ await LoopbackServerFactory.CreateClientAndServerAsync(`
`391`	`391`	`},`
`392`	`392`	`async server =>`
`393`	`393`	`{`
`394`		`- await server.HandleRequestAsync(headers: new[]`
	`394`	`+ // The client may detect the bad header and close the connection before we are done sending the response.`
	`395`	`+ // So, eat any IOException that occurs here.`
	`396`	`+ try`
`395`	`397`	`{`
`396`		`- new HttpHeaderData("", "foo")`
`397`		`- });`
	`398`	`+ await server.HandleRequestAsync(headers: new[]`
	`399`	`+ {`
	`400`	`+ new HttpHeaderData("", "foo")`
	`401`	`+ });`
	`402`	`+ }`
	`403`	`+ catch (IOException) { }`
`398`	`404`	`});`
`399`	`405`	`}`
`400`	`406`