if (connection.noNewExchanges) {
        assertThat(eventSequence).matchesPredicate { deque ->
          deque.any { it is NoNewExchanges && it.connection == connection }
        }
      }
    }

    logEvent(ConnectionEvent.ConnectionReleased(System.nanoTime(), connection, call))
  }

    return connection
  }

  override fun trackFailure(
    call: RealCall,
    e: IOException?,
  ) {
    // Do nothing.
  }

  override fun noNewExchanges() {
    // Do nothing.
  }

  override fun cancel() {
    canceled = true
    // Close the raw socket so we don't end up doing synchronous I/O.
    rawSocket?.closeQuietly()
  }

    return ChunkedSource(url)
  }

  private fun newUnknownLengthSource(url: HttpUrl): Source {
    check(state == STATE_OPEN_RESPONSE_BODY) { "state: $state" }
    state = STATE_READING_RESPONSE_BODY
    carrier.noNewExchanges()
    return UnknownLengthSource(url)
  }

  /**
   * Sets the delegate of `timeout` to [Timeout.NONE] and resets its underlying timeout

          noNewExchangesEvent = !connection.noNewExchanges
          connection.noNewExchanges = true
          call.releaseConnectionNoEvents()
        }
      if (toClose != null) {
        toClose.closeQuietly()
        connectionListener.connectionClosed(connection)
      } else if (noNewExchangesEvent) {
        connectionListener.noNewExchanges(connection)
      }
    }
    return null
  }

    val toClose: Socket? =
      candidate.withLock {
        when {
          !healthy -> {
            noNewExchangesEvent = !candidate.noNewExchanges
            candidate.noNewExchanges = true
            call.releaseConnectionNoEvents()
          }

          candidate.noNewExchanges || !sameHostAndPort(candidate.route().address.url) -> {
            call.releaseConnectionNoEvents()
          }

          else -> {