toClose.closeQuietly()
        connectionListener.connectionClosed(connection)
      } else if (noNewExchangesEvent) {
        connectionListener.noNewExchanges(connection)
      }
    }
    return null
  }

  fun put(connection: RealConnection) {
    connection.lock.assertHeld()

    connections.add(connection)
//    connection.queueEvent { connectionListener.connectEnd(connection) }
    scheduleCloser()

          buildConnectionPool(
            connectionListener = connectionListener,
            taskRunner = taskRunner,
          ),
        )
        .dispatcher(Dispatcher(backend.executor))
        .taskRunnerInternal(taskRunner)
    } else {
      OkHttpClient.Builder()
        .connectionPool(ConnectionPool(connectionListener = connectionListener))
    }

  private var handshake: Handshake?,
  private var protocol: Protocol?,
  private var source: BufferedSource?,
  private var sink: BufferedSink?,
  private val pingIntervalMillis: Int,
  internal val connectionListener: ConnectionListener,
) : Http2Connection.Listener(), Connection, ExchangeCodec.Carrier {
  private var http2Connection: Http2Connection? = null

  internal val lock: ReentrantLock = ReentrantLock()

        }
      if (this.connection == null) {
        toClose?.closeQuietly()
        eventListener.connectionReleased(this, connection)
        connection.connectionListener.connectionReleased(connection, this)
        if (toClose != null) {
          connection.connectionListener.connectionClosed(connection)
        }
      } else {
        check(toClose == null) // If we still have a connection we shouldn't be closing any sockets.

          handshake = handshake,
          protocol = protocol,
          source = source,
          sink = sink,
          pingIntervalMillis = pingIntervalMillis,
          connectionListener = connectionPool.connectionListener,
        )
      this.connection = connection
      connection.start()

      // Success.
      user.callConnectEnd(route, protocol)
      success = true

import java.net.Proxy
import java.net.ProxySelector
import java.net.SocketAddress
import java.net.URI
import java.net.UnknownHostException
import kotlin.test.assertFailsWith
import okhttp3.Address
import okhttp3.ConnectionListener
import okhttp3.FakeDns
import okhttp3.OkHttpClientTestRule
import okhttp3.Request
import okhttp3.Route
import okhttp3.TestValueFactory
import okhttp3.internal.connection.RouteSelector.Companion.socketHost

    different cipher suite than before! OkHttp's defaults cipher suites are selected for good
    security and performance.

 *  New: `ConnectionListener` publishes events for connects, disconnects, and use of pooled
    connections.

 *  Fix: Immediately update the connection's flow control window instead of waiting for the
    receiving stream to process it.