Remove _socket field from HttpConnection (#66416)

geoffkizer · Geoffrey Kizer · web-flow · commit bc5e386676ec · 2022-03-14T21:36:24.000-07:00
* remove _socket from HttpConnection

Co-authored-by: Geoffrey Kizer &lt;geoffrek@windows.microsoft.com&gt;
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs
@@ -43,7 +43,6 @@ internal sealed partial class HttpConnection : HttpConnectionBase
         private static readonly ulong s_http11Bytes = BitConverter.ToUInt64(Encoding.ASCII.GetBytes("HTTP/1.1"));
 
         private readonly HttpConnectionPool _pool;
-        private readonly Socket? _socket; // used for polling; _stream should be used for all reading/writing. _stream owns disposal.
         private readonly Stream _stream;
         private readonly TransportContext? _transportContext;
         private readonly WeakReference<HttpConnection> _weakThisRef;
@@ -74,7 +73,6 @@ internal sealed partial class HttpConnection : HttpConnectionBase
 
         public HttpConnection(
             HttpConnectionPool pool,
-            Socket? socket,
             Stream stream,
             TransportContext? transportContext)
         {
@@ -83,7 +81,6 @@ public HttpConnection(
 
             _pool = pool;
             _stream = stream;
-            _socket = socket;
 
             _transportContext = transportContext;
 
@@ -158,13 +155,13 @@ public bool PrepareForReuse(bool async)
             // Check to see if we've received anything on the connection; if we have, that's
             // either erroneous data (we shouldn't have received anything yet) or the connection
             // has been closed; either way, we can't use it.
-            if (!async && _socket is not null)
+            if (!async && _stream is NetworkStream networkStream)
             {
                 // Directly poll the socket rather than doing an async read, so that we can
                 // issue an appropriate sync read when we actually need it.
                 try
                 {
-                    return !_socket.Poll(0, SelectMode.SelectRead);
+                    return !networkStream.Socket.Poll(0, SelectMode.SelectRead);
                 }
                 catch (Exception e) when (e is SocketException || e is ObjectDisposedException)
                 {
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs
@@ -555,7 +555,7 @@ private async ValueTask<HttpConnection> GetHttp11ConnectionAsync(HttpRequestMess
             }
         }
 
-        private async Task HandleHttp11Downgrade(HttpRequestMessage request, Socket? socket, Stream stream, TransportContext? transportContext, CancellationToken cancellationToken)
+        private async Task HandleHttp11Downgrade(HttpRequestMessage request, Stream stream, TransportContext? transportContext, CancellationToken cancellationToken)
         {
             if (NetEventSource.Log.IsEnabled()) Trace("Server does not support HTTP2; disabling HTTP2 use and proceeding with HTTP/1.1 connection");
 
@@ -610,7 +610,7 @@ private async Task HandleHttp11Downgrade(HttpRequestMessage request, Socket? soc
             try
             {
                 // Note, the same CancellationToken from the original HTTP2 connection establishment still applies here.
-                http11Connection = await ConstructHttp11ConnectionAsync(true, socket, stream, transportContext, request, cancellationToken).ConfigureAwait(false);
+                http11Connection = await ConstructHttp11ConnectionAsync(true, stream, transportContext, request, cancellationToken).ConfigureAwait(false);
             }
             catch (OperationCanceledException oce) when (oce.CancellationToken == cancellationToken)
             {
@@ -635,7 +635,7 @@ private async Task AddHttp2ConnectionAsync(HttpRequestMessage request)
             {
                 try
                 {
-                    (Socket? socket, Stream stream, TransportContext? transportContext) = await ConnectAsync(request, true, cts.Token).ConfigureAwait(false);
+                    (Stream stream, TransportContext? transportContext) = await ConnectAsync(request, true, cts.Token).ConfigureAwait(false);
 
                     if (IsSecure)
                     {
@@ -656,7 +656,7 @@ private async Task AddHttp2ConnectionAsync(HttpRequestMessage request)
                         else
                         {
                             // We established an SSL connection, but the server denied our request for HTTP2.
-                            await HandleHttp11Downgrade(request, socket, stream, transportContext, cts.Token).ConfigureAwait(false);
+                            await HandleHttp11Downgrade(request, stream, transportContext, cts.Token).ConfigureAwait(false);
                             return;
                         }
                     }
@@ -1347,21 +1347,20 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool
 
         private CancellationTokenSource GetConnectTimeoutCancellationTokenSource() => new CancellationTokenSource(Settings._connectTimeout);
 
-        private async ValueTask<(Socket?, Stream, TransportContext?)> ConnectAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
+        private async ValueTask<(Stream, TransportContext?)> ConnectAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
         {
             Stream? stream = null;
-            Socket? socket = null;
             switch (_kind)
             {
                 case HttpConnectionKind.Http:
                 case HttpConnectionKind.Https:
                 case HttpConnectionKind.ProxyConnect:
                     Debug.Assert(_originAuthority != null);
-                    (socket, stream) = await ConnectToTcpHostAsync(_originAuthority.IdnHost, _originAuthority.Port, request, async, cancellationToken).ConfigureAwait(false);
+                    stream = await ConnectToTcpHostAsync(_originAuthority.IdnHost, _originAuthority.Port, request, async, cancellationToken).ConfigureAwait(false);
                     break;
 
                 case HttpConnectionKind.Proxy:
-                    (socket, stream) = await ConnectToTcpHostAsync(_proxyUri!.IdnHost, _proxyUri.Port, request, async, cancellationToken).ConfigureAwait(false);
+                    stream = await ConnectToTcpHostAsync(_proxyUri!.IdnHost, _proxyUri.Port, request, async, cancellationToken).ConfigureAwait(false);
                     break;
 
                 case HttpConnectionKind.ProxyTunnel:
@@ -1371,17 +1370,11 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool
 
                 case HttpConnectionKind.SocksTunnel:
                 case HttpConnectionKind.SslSocksTunnel:
-                    (socket, stream) = await EstablishSocksTunnel(request, async, cancellationToken).ConfigureAwait(false);
+                    stream = await EstablishSocksTunnel(request, async, cancellationToken).ConfigureAwait(false);
                 break;
             }
 
             Debug.Assert(stream != null);
-            if (socket is null && stream is NetworkStream ns)
-            {
-                // We weren't handed a socket directly.  But if we're able to extract one, do so.
-                // Most likely case here is a ConnectCallback was used and returned a NetworkStream.
-                socket = ns.Socket;
-            }
 
             TransportContext? transportContext = null;
             if (IsSecure)
@@ -1402,15 +1395,14 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool
                 stream = sslStream;
             }
 
-            return (socket, stream, transportContext);
+            return (stream, transportContext);
         }
 
-        private async ValueTask<(Socket?, Stream)> ConnectToTcpHostAsync(string host, int port, HttpRequestMessage initialRequest, bool async, CancellationToken cancellationToken)
+        private async ValueTask<Stream> ConnectToTcpHostAsync(string host, int port, HttpRequestMessage initialRequest, bool async, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
             var endPoint = new DnsEndPoint(host, port);
-            Socket? socket = null;
             Stream? stream = null;
             try
             {
@@ -1433,28 +1425,34 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool
                 else
                 {
                     // Otherwise, create and connect a socket using default settings.
-                    socket = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };
-
-                    if (async)
-                    {
-                        await socket.ConnectAsync(endPoint, cancellationToken).ConfigureAwait(false);
-                    }
-                    else
+                    Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };
+                    try
                     {
-                        using (cancellationToken.UnsafeRegister(static s => ((Socket)s!).Dispose(), socket))
+                        if (async)
                         {
-                            socket.Connect(endPoint);
+                            await socket.ConnectAsync(endPoint, cancellationToken).ConfigureAwait(false);
+                        }
+                        else
+                        {
+                            using (cancellationToken.UnsafeRegister(static s => ((Socket)s!).Dispose(), socket))
+                            {
+                                socket.Connect(endPoint);
+                            }
                         }
-                    }
 
-                    stream = new NetworkStream(socket, ownsSocket: true);
+                        stream = new NetworkStream(socket, ownsSocket: true);
+                    }
+                    catch
+                    {
+                        socket.Dispose();
+                        throw;
+                    }
                 }
 
-                return (socket, stream);
+                return stream;
             }
             catch (Exception ex)
             {
-                socket?.Dispose();
                 throw ex is OperationCanceledException oce && oce.CancellationToken == cancellationToken ?
                     CancellationHelper.CreateOperationCanceledException(innerException: null, cancellationToken) :
                     ConnectHelper.CreateWrappedException(ex, endPoint.Host, endPoint.Port, cancellationToken);
@@ -1463,9 +1461,8 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool
 
         internal async ValueTask<HttpConnection> CreateHttp11ConnectionAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
         {
-            (Socket? socket, Stream stream, TransportContext? transportContext) = await ConnectAsync(request, async, cancellationToken).ConfigureAwait(false);
-
-            return await ConstructHttp11ConnectionAsync(async, socket, stream!, transportContext, request, cancellationToken).ConfigureAwait(false);
+            (Stream stream, TransportContext? transportContext) = await ConnectAsync(request, async, cancellationToken).ConfigureAwait(false);
+            return await ConstructHttp11ConnectionAsync(async, stream, transportContext, request, cancellationToken).ConfigureAwait(false);
         }
 
         private SslClientAuthenticationOptions GetSslOptionsForRequest(HttpRequestMessage request)
@@ -1528,15 +1525,10 @@ private async ValueTask<Stream> ApplyPlaintextFilterAsync(bool async, Stream str
             return newStream;
         }
 
-        private async ValueTask<HttpConnection> ConstructHttp11ConnectionAsync(bool async, Socket? socket, Stream stream, TransportContext? transportContext, HttpRequestMessage request, CancellationToken cancellationToken)
+        private async ValueTask<HttpConnection> ConstructHttp11ConnectionAsync(bool async, Stream stream, TransportContext? transportContext, HttpRequestMessage request, CancellationToken cancellationToken)
         {
             Stream newStream = await ApplyPlaintextFilterAsync(async, stream, HttpVersion.Version11, request, cancellationToken).ConfigureAwait(false);
-            if (newStream != stream)
-            {
-                // If a plaintext filter created a new stream, we can't trust that the socket is still applicable.
-                socket = null;
-            }
-            return new HttpConnection(this, socket, newStream, transportContext);
+            return new HttpConnection(this, newStream, transportContext);
         }
 
         private async ValueTask<Http2Connection> ConstructHttp2ConnectionAsync(Stream stream, HttpRequestMessage request, CancellationToken cancellationToken)
@@ -1589,12 +1581,12 @@ private async ValueTask<Stream> EstablishProxyTunnelAsync(bool async, HttpReques
             }
         }
 
-        private async ValueTask<(Socket? socket, Stream stream)> EstablishSocksTunnel(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
+        private async ValueTask<Stream> EstablishSocksTunnel(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
         {
             Debug.Assert(_originAuthority != null);
             Debug.Assert(_proxyUri != null);
 
-            (Socket? socket, Stream stream) = await ConnectToTcpHostAsync(_proxyUri.IdnHost, _proxyUri.Port, request, async, cancellationToken).ConfigureAwait(false);
+            Stream stream = await ConnectToTcpHostAsync(_proxyUri.IdnHost, _proxyUri.Port, request, async, cancellationToken).ConfigureAwait(false);
 
             try
             {
@@ -1606,7 +1598,7 @@ private async ValueTask<Stream> EstablishProxyTunnelAsync(bool async, HttpReques
                 throw new HttpRequestException(SR.net_http_request_aborted, e);
             }
 
-            return (socket, stream);
+            return stream;
         }
 
         private void HandleHttp11ConnectionFailure(HttpRequestMessage request, Exception e)

Original file line number	Diff line number	Diff line change
`@@ -555,7 +555,7 @@ private async ValueTask<HttpConnection> GetHttp11ConnectionAsync(HttpRequestMess`
`555`	`555`	`}`
`556`	`556`	`}`
`557`	`557`
`558`		`- private async Task HandleHttp11Downgrade(HttpRequestMessage request, Socket? socket, Stream stream, TransportContext? transportContext, CancellationToken cancellationToken)`
	`558`	`+ private async Task HandleHttp11Downgrade(HttpRequestMessage request, Stream stream, TransportContext? transportContext, CancellationToken cancellationToken)`
`559`	`559`	`{`
`560`	`560`	`if (NetEventSource.Log.IsEnabled()) Trace("Server does not support HTTP2; disabling HTTP2 use and proceeding with HTTP/1.1 connection");`
`561`	`561`
`@@ -610,7 +610,7 @@ private async Task HandleHttp11Downgrade(HttpRequestMessage request, Socket? soc`
`610`	`610`	`try`
`611`	`611`	`{`
`612`	`612`	`// Note, the same CancellationToken from the original HTTP2 connection establishment still applies here.`
`613`		`- http11Connection = await ConstructHttp11ConnectionAsync(true, socket, stream, transportContext, request, cancellationToken).ConfigureAwait(false);`
	`613`	`+ http11Connection = await ConstructHttp11ConnectionAsync(true, stream, transportContext, request, cancellationToken).ConfigureAwait(false);`
`614`	`614`	`}`
`615`	`615`	`catch (OperationCanceledException oce) when (oce.CancellationToken == cancellationToken)`
`616`	`616`	`{`
`@@ -635,7 +635,7 @@ private async Task AddHttp2ConnectionAsync(HttpRequestMessage request)`
`635`	`635`	`{`
`636`	`636`	`try`
`637`	`637`	`{`
`638`		`- (Socket? socket, Stream stream, TransportContext? transportContext) = await ConnectAsync(request, true, cts.Token).ConfigureAwait(false);`
	`638`	`+ (Stream stream, TransportContext? transportContext) = await ConnectAsync(request, true, cts.Token).ConfigureAwait(false);`
`639`	`639`
`640`	`640`	`if (IsSecure)`
`641`	`641`	`{`
`@@ -656,7 +656,7 @@ private async Task AddHttp2ConnectionAsync(HttpRequestMessage request)`
`656`	`656`	`else`
`657`	`657`	`{`
`658`	`658`	`// We established an SSL connection, but the server denied our request for HTTP2.`
`659`		`- await HandleHttp11Downgrade(request, socket, stream, transportContext, cts.Token).ConfigureAwait(false);`
	`659`	`+ await HandleHttp11Downgrade(request, stream, transportContext, cts.Token).ConfigureAwait(false);`
`660`	`660`	`return;`
`661`	`661`	`}`
`662`	`662`	`}`
`@@ -1347,21 +1347,20 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool`
`1347`	`1347`
`1348`	`1348`	`private CancellationTokenSource GetConnectTimeoutCancellationTokenSource() => new CancellationTokenSource(Settings._connectTimeout);`
`1349`	`1349`
`1350`		`- private async ValueTask<(Socket?, Stream, TransportContext?)> ConnectAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)`
	`1350`	`+ private async ValueTask<(Stream, TransportContext?)> ConnectAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)`
`1351`	`1351`	`{`
`1352`	`1352`	`Stream? stream = null;`
`1353`		`- Socket? socket = null;`
`1354`	`1353`	`switch (_kind)`
`1355`	`1354`	`{`
`1356`	`1355`	`case HttpConnectionKind.Http:`
`1357`	`1356`	`case HttpConnectionKind.Https:`
`1358`	`1357`	`case HttpConnectionKind.ProxyConnect:`
`1359`	`1358`	`Debug.Assert(_originAuthority != null);`
`1360`		`- (socket, stream) = await ConnectToTcpHostAsync(_originAuthority.IdnHost, _originAuthority.Port, request, async, cancellationToken).ConfigureAwait(false);`
	`1359`	`+ stream = await ConnectToTcpHostAsync(_originAuthority.IdnHost, _originAuthority.Port, request, async, cancellationToken).ConfigureAwait(false);`
`1361`	`1360`	`break;`
`1362`	`1361`
`1363`	`1362`	`case HttpConnectionKind.Proxy:`
`1364`		`- (socket, stream) = await ConnectToTcpHostAsync(_proxyUri!.IdnHost, _proxyUri.Port, request, async, cancellationToken).ConfigureAwait(false);`
	`1363`	`+ stream = await ConnectToTcpHostAsync(_proxyUri!.IdnHost, _proxyUri.Port, request, async, cancellationToken).ConfigureAwait(false);`
`1365`	`1364`	`break;`
`1366`	`1365`
`1367`	`1366`	`case HttpConnectionKind.ProxyTunnel:`
`@@ -1371,17 +1370,11 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool`
`1371`	`1370`
`1372`	`1371`	`case HttpConnectionKind.SocksTunnel:`
`1373`	`1372`	`case HttpConnectionKind.SslSocksTunnel:`
`1374`		`- (socket, stream) = await EstablishSocksTunnel(request, async, cancellationToken).ConfigureAwait(false);`
	`1373`	`+ stream = await EstablishSocksTunnel(request, async, cancellationToken).ConfigureAwait(false);`
`1375`	`1374`	`break;`
`1376`	`1375`	`}`
`1377`	`1376`
`1378`	`1377`	`Debug.Assert(stream != null);`
`1379`		`- if (socket is null && stream is NetworkStream ns)`
`1380`		`- {`
`1381`		`- // We weren't handed a socket directly. But if we're able to extract one, do so.`
`1382`		`- // Most likely case here is a ConnectCallback was used and returned a NetworkStream.`
`1383`		`- socket = ns.Socket;`
`1384`		`- }`
`1385`	`1378`
`1386`	`1379`	`TransportContext? transportContext = null;`
`1387`	`1380`	`if (IsSecure)`
`@@ -1402,15 +1395,14 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool`
`1402`	`1395`	`stream = sslStream;`
`1403`	`1396`	`}`
`1404`	`1397`
`1405`		`- return (socket, stream, transportContext);`
	`1398`	`+ return (stream, transportContext);`
`1406`	`1399`	`}`
`1407`	`1400`
`1408`		`- private async ValueTask<(Socket?, Stream)> ConnectToTcpHostAsync(string host, int port, HttpRequestMessage initialRequest, bool async, CancellationToken cancellationToken)`
	`1401`	`+ private async ValueTask<Stream> ConnectToTcpHostAsync(string host, int port, HttpRequestMessage initialRequest, bool async, CancellationToken cancellationToken)`
`1409`	`1402`	`{`
`1410`	`1403`	`cancellationToken.ThrowIfCancellationRequested();`
`1411`	`1404`
`1412`	`1405`	`var endPoint = new DnsEndPoint(host, port);`
`1413`		`- Socket? socket = null;`
`1414`	`1406`	`Stream? stream = null;`
`1415`	`1407`	`try`
`1416`	`1408`	`{`
`@@ -1433,28 +1425,34 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool`
`1433`	`1425`	`else`
`1434`	`1426`	`{`
`1435`	`1427`	`// Otherwise, create and connect a socket using default settings.`
`1436`		`- socket = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };`
`1437`		`-`
`1438`		`- if (async)`
`1439`		`- {`
`1440`		`- await socket.ConnectAsync(endPoint, cancellationToken).ConfigureAwait(false);`
`1441`		`- }`
`1442`		`- else`
	`1428`	`+ Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };`
	`1429`	`+ try`
`1443`	`1430`	`{`
`1444`		`- using (cancellationToken.UnsafeRegister(static s => ((Socket)s!).Dispose(), socket))`
	`1431`	`+ if (async)`
`1445`	`1432`	`{`
`1446`		`- socket.Connect(endPoint);`
	`1433`	`+ await socket.ConnectAsync(endPoint, cancellationToken).ConfigureAwait(false);`
	`1434`	`+ }`
	`1435`	`+ else`
	`1436`	`+ {`
	`1437`	`+ using (cancellationToken.UnsafeRegister(static s => ((Socket)s!).Dispose(), socket))`
	`1438`	`+ {`
	`1439`	`+ socket.Connect(endPoint);`
	`1440`	`+ }`
`1447`	`1441`	`}`
`1448`		`- }`
`1449`	`1442`
`1450`		`- stream = new NetworkStream(socket, ownsSocket: true);`
	`1443`	`+ stream = new NetworkStream(socket, ownsSocket: true);`
	`1444`	`+ }`
	`1445`	`+ catch`
	`1446`	`+ {`
	`1447`	`+ socket.Dispose();`
	`1448`	`+ throw;`
	`1449`	`+ }`
`1451`	`1450`	`}`
`1452`	`1451`
`1453`		`- return (socket, stream);`
	`1452`	`+ return stream;`
`1454`	`1453`	`}`
`1455`	`1454`	`catch (Exception ex)`
`1456`	`1455`	`{`
`1457`		`- socket?.Dispose();`
`1458`	`1456`	`throw ex is OperationCanceledException oce && oce.CancellationToken == cancellationToken ?`
`1459`	`1457`	`CancellationHelper.CreateOperationCanceledException(innerException: null, cancellationToken) :`
`1460`	`1458`	`ConnectHelper.CreateWrappedException(ex, endPoint.Host, endPoint.Port, cancellationToken);`
`@@ -1463,9 +1461,8 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool`
`1463`	`1461`
`1464`	`1462`	`internal async ValueTask<HttpConnection> CreateHttp11ConnectionAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)`
`1465`	`1463`	`{`
`1466`		`- (Socket? socket, Stream stream, TransportContext? transportContext) = await ConnectAsync(request, async, cancellationToken).ConfigureAwait(false);`
`1467`		`-`
`1468`		`- return await ConstructHttp11ConnectionAsync(async, socket, stream!, transportContext, request, cancellationToken).ConfigureAwait(false);`
	`1464`	`+ (Stream stream, TransportContext? transportContext) = await ConnectAsync(request, async, cancellationToken).ConfigureAwait(false);`
	`1465`	`+ return await ConstructHttp11ConnectionAsync(async, stream, transportContext, request, cancellationToken).ConfigureAwait(false);`
`1469`	`1466`	`}`
`1470`	`1467`
`1471`	`1468`	`private SslClientAuthenticationOptions GetSslOptionsForRequest(HttpRequestMessage request)`
`@@ -1528,15 +1525,10 @@ private async ValueTask<Stream> ApplyPlaintextFilterAsync(bool async, Stream str`
`1528`	`1525`	`return newStream;`
`1529`	`1526`	`}`
`1530`	`1527`
`1531`		`- private async ValueTask<HttpConnection> ConstructHttp11ConnectionAsync(bool async, Socket? socket, Stream stream, TransportContext? transportContext, HttpRequestMessage request, CancellationToken cancellationToken)`
	`1528`	`+ private async ValueTask<HttpConnection> ConstructHttp11ConnectionAsync(bool async, Stream stream, TransportContext? transportContext, HttpRequestMessage request, CancellationToken cancellationToken)`
`1532`	`1529`	`{`
`1533`	`1530`	`Stream newStream = await ApplyPlaintextFilterAsync(async, stream, HttpVersion.Version11, request, cancellationToken).ConfigureAwait(false);`
`1534`		`- if (newStream != stream)`
`1535`		`- {`
`1536`		`- // If a plaintext filter created a new stream, we can't trust that the socket is still applicable.`
`1537`		`- socket = null;`
`1538`		`- }`
`1539`		`- return new HttpConnection(this, socket, newStream, transportContext);`
	`1531`	`+ return new HttpConnection(this, newStream, transportContext);`
`1540`	`1532`	`}`
`1541`	`1533`
`1542`	`1534`	`private async ValueTask<Http2Connection> ConstructHttp2ConnectionAsync(Stream stream, HttpRequestMessage request, CancellationToken cancellationToken)`
`@@ -1589,12 +1581,12 @@ private async ValueTask<Stream> EstablishProxyTunnelAsync(bool async, HttpReques`
`1589`	`1581`	`}`
`1590`	`1582`	`}`
`1591`	`1583`
`1592`		`- private async ValueTask<(Socket? socket, Stream stream)> EstablishSocksTunnel(HttpRequestMessage request, bool async, CancellationToken cancellationToken)`
	`1584`	`+ private async ValueTask<Stream> EstablishSocksTunnel(HttpRequestMessage request, bool async, CancellationToken cancellationToken)`
`1593`	`1585`	`{`
`1594`	`1586`	`Debug.Assert(_originAuthority != null);`
`1595`	`1587`	`Debug.Assert(_proxyUri != null);`
`1596`	`1588`
`1597`		`- (Socket? socket, Stream stream) = await ConnectToTcpHostAsync(_proxyUri.IdnHost, _proxyUri.Port, request, async, cancellationToken).ConfigureAwait(false);`
	`1589`	`+ Stream stream = await ConnectToTcpHostAsync(_proxyUri.IdnHost, _proxyUri.Port, request, async, cancellationToken).ConfigureAwait(false);`
`1598`	`1590`
`1599`	`1591`	`try`
`1600`	`1592`	`{`
`@@ -1606,7 +1598,7 @@ private async ValueTask<Stream> EstablishProxyTunnelAsync(bool async, HttpReques`
`1606`	`1598`	`throw new HttpRequestException(SR.net_http_request_aborted, e);`
`1607`	`1599`	`}`
`1608`	`1600`
`1609`		`- return (socket, stream);`
	`1601`	`+ return stream;`
`1610`	`1602`	`}`
`1611`	`1603`
`1612`	`1604`	`private void HandleHttp11ConnectionFailure(HttpRequestMessage request, Exception e)`