// Make sure this connection is healthy & eligible for new exchanges. If it's no longer needed
    // then we're on the hook to close it.
    val healthy = candidate.isHealthy(connectionUser.doExtensiveHealthChecks())
    var noNewExchangesEvent = false
    val toClose: Socket? =
      candidate.withLock {
        when {
          !healthy -> {
            noNewExchangesEvent = !candidate.noNewExchanges

    userResponse: Response,
    exchange: Exchange?,
  ): Request? {
    val route = exchange?.connection?.route()
    val responseCode = userResponse.code

    val method = userResponse.request.method
    when (responseCode) {
      HTTP_PROXY_AUTH -> {
        val selectedProxy = route!!.proxy
        if (selectedProxy.type() != Proxy.Type.HTTP) {

 *  Fix: Don't throw when converting an `HttpUrl` to a `java.net.URI`.
    Previously URLs with special characters like `|` and `[` would break when
    subjected to URI’s overly-strict validation.
 *  Fix: Don't re-encode `+` as `%20` in encoded URL query strings. OkHttp
    prefers `%20` when doing its own encoding, but will retain `+` when that is
    provided.

 *  Fix: Don't infinite loop when a received web socket message has self-terminating compressed
    data.

 *  Fix: Don't fail the call when the response code is ‘HTTP 102 Processing’ or ‘HTTP 103 Early
    Hints’.

 *  Fix: Honor interceptors' changes to connect and read timeouts.

 *  Fix: Recover gracefully when a cached response is corrupted on disk.

            writerToClose = this.writer
            this.writer = null
            streamsToClose =
              when {
                writerToClose != null && reader == null -> this.streams
                else -> null
              }
            this.taskQueue.shutdown()
          } else {
            // When we request a graceful close also schedule a cancel of the web socket.

   *
   *  - "Strict": the cookie is omitted when the subject URL is an embedded resource or a
   *    potentially-destructive navigation.
   *
   *  - "Lax": the cookie is omitted when the subject URL is an embedded resource. It is sent for
   *    potentially-destructive navigation. This is the default value.
   *
   *  - "None": the cookie is always sent. The "Secure" attribute must also be set when setting this
   *    value.
   */

  }

  /**
   * Either writes this request to [sink] or measures its content length. We have one method do
   * double-duty to make sure the counting and content are consistent, particularly when it comes
   * to awkward operations like measuring the encoded length of header strings, or the
   * length-in-digits of an encoded integer.
   */
  @Throws(IOException::class)
  private fun writeOrCountBytes(

   * timeouts (due to a problem with the transport). When a stream times out we don't know whether
   * the problem impacts just one stream or the entire connection.
   *
   * To differentiate the two cases we ping the server when a stream times out. If the overall
   * connection is fine the ping will receive a pong; otherwise it won't.
   *

        )
        append(").*")
      },
    )

  private val testLogHandler =
    object : Handler() {
      override fun publish(record: LogRecord) {
        val recorded =
          when (record.loggerName) {
            TaskRunner::class.java.name -> recordTaskRunner
            Http2::class.java.name -> recordFrames
            "javax.net.ssl" -> recordSslDebug && !sslExcludeFilter.matches(record.message)

      }

      else -> {
        toEvict = null
        toEvictIdleAtNs = -1L
      }
    }

    when {
      toEvict != null -> {
        // We've chosen a connection to evict. Confirm it's still okay to be evicted, then close it.
        toEvict.withLock {
          if (toEvict.calls.isNotEmpty()) return 0L // No longer idle.