Another websocket fix

src/Titanium.Web.Proxy/ExplicitClientHandler.cs

@@ -140,8 +140,8 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
                             {
                                 // todo: this is a hack, because Titanium does not support HTTP protocol changing currently
                                 var connection = await tcpConnectionFactory.GetServerConnection(this, connectArgs,
-                                    isConnect: true, applicationProtocols: SslExtensions.Http2ProtocolAsList,
-                                    noCache: true, cancellationToken: cancellationToken);
+                                    true, SslExtensions.Http2ProtocolAsList,
+                                    true, cancellationToken);
 
                                 http2Supported = connection.NegotiatedApplicationProtocol ==
                                                  SslApplicationProtocol.Http2;
@@ -170,8 +170,8 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
                                 // don't pass cancellation token here
                                 // it could cause floating server connections when client exits
                                 prefetchConnectionTask = tcpConnectionFactory.GetServerConnection(this, connectArgs,
-                                                        isConnect: true, applicationProtocols: null, noCache: false,
-                                                        cancellationToken: CancellationToken.None);
+                                                        true, null, false,
+                                                        CancellationToken.None);
                             }
                         }
 
@@ -253,8 +253,8 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
                         // If we detected that client tunnel CONNECTs without SSL by checking for empty client hello then 
                         // this connection should not be HTTPS.
                         var connection = await tcpConnectionFactory.GetServerConnection(this, connectArgs,
-                                                        isConnect: true, applicationProtocols: SslExtensions.Http2ProtocolAsList,
-                                                        noCache: true, cancellationToken: cancellationToken);
+                                                        true, SslExtensions.Http2ProtocolAsList,
+                                                        true, cancellationToken);
 
                         try
                         {
@@ -325,8 +325,8 @@ await TcpHelper.SendRaw(clientStream, connection.Stream, BufferPool,
                         }
 
                         var connection = await tcpConnectionFactory.GetServerConnection(this, connectArgs,
-                                                        isConnect: true, applicationProtocols: SslExtensions.Http2ProtocolAsList,
-                                                        noCache: true, cancellationToken: cancellationToken);
+                                                        true, SslExtensions.Http2ProtocolAsList,
+                                                        true, cancellationToken);
                         try
                         {
 #if NETSTANDARD2_1

src/Titanium.Web.Proxy/Network/Tcp/TcpConnectionFactory.cs

@@ -190,6 +190,7 @@ internal async Task<TcpServerConnection> GetServerConnection(ProxyServer server,
                 customUpStreamProxy ?? (isHttps ? server.UpStreamHttpsProxy : server.UpStreamHttpProxy),
                 noCache, cancellationToken);
         }
+
         /// <summary>
         ///     Gets a TCP connection to server from connection pool.
         /// </summary>
@@ -441,7 +442,7 @@ private async Task<TcpServerConnection> createServerConnection(string remoteHost
                         connectRequest.Headers.AddHeader(HttpHeader.GetProxyAuthorizationHeader(externalProxy.UserName, externalProxy.Password));
                     }
 
-                    await stream.WriteRequestAsync(connectRequest, cancellationToken: cancellationToken);
+                    await stream.WriteRequestAsync(connectRequest, cancellationToken);
 
                     var httpStatus = await stream.ReadResponseStatus(cancellationToken);
 

src/Titanium.Web.Proxy/RequestHandler.cs

@@ -261,11 +261,19 @@ private async Task<RetryResult> handleHttpSessionRequest(SessionEventArgs args,
             // do not cache server connections for WebSockets
             bool noCache = args.HttpClient.Request.UpgradeToWebSocket;
 
+            if (noCache)
+            {
+                serverConnection = null;
+            }
+
             // a connection generator task with captured parameters via closure.
             Func<Task<TcpServerConnection>> generator = () =>
-                            tcpConnectionFactory.GetServerConnection(this, args, isConnect: false,
-                                    applicationProtocol: sslApplicationProtocol,
-                                    noCache: noCache, cancellationToken: cancellationToken);
+                tcpConnectionFactory.GetServerConnection(this,
+                    args,
+                    false,
+                    sslApplicationProtocol,
+                    noCache,
+                    cancellationToken);
 
             // for connection pool, retry fails until cache is exhausted.   
             return await retryPolicy<ServerConnectionException>().ExecuteAsync(async (connection) =>

src/Titanium.Web.Proxy/TransparentClientHandler.cs

@@ -89,9 +89,9 @@ private async Task handleClient(TransparentProxyEndPoint endPoint, TcpClientConn
                     else
                     {
                         var connection = await tcpConnectionFactory.GetServerConnection(httpsHostName, endPoint.Port,
-                                    httpVersion: HttpHeader.VersionUnknown, isHttps: false, applicationProtocols: null,
-                                    isConnect: true, proxyServer: this, session:null, upStreamEndPoint: UpStreamEndPoint,
-                                    externalProxy: UpStreamHttpsProxy, noCache: true, cancellationToken: cancellationToken);
+                                    HttpHeader.VersionUnknown, false, null,
+                                    true, this, null, UpStreamEndPoint,
+                                    UpStreamHttpsProxy, true, cancellationToken);
 
                         try
                         {