} catch (e: IOException) {
      eventListener.responseFailed(call, e)
      trackFailure(e)
      throw e
    }
  }

  @Throws(IOException::class)
  fun peekTrailers(): Headers? = codec.peekTrailers()

  fun upgradeToSocket(): Socket {
    call.timeoutEarlyExit()
    (codec.carrier as RealConnection).useAsSocket()

    eventListener.requestBodyStart(call)

      !response.promisesBody() -> 0L
      else -> response.headersContentLength()
    }

  override fun openResponseBodySource(response: Response): Source = stream!!.source

  override fun peekTrailers(): Headers? = stream!!.peekTrailers()

  override fun cancel() {
    canceled = true
    stream?.closeLater(ErrorCode.CANCEL)
  }

  companion object {
    private const val CONNECTION = "connection"

  @Throws(IOException::class)
  fun openResponseBodySource(response: Response): Source

  /** Returns the trailers after the HTTP response if they're ready. May be empty. */
  @Throws(IOException::class)
  fun peekTrailers(): Headers?

  /**
   * Cancel this stream. Resources held by this stream will be cleaned up, though not synchronously.
   * That may happen later by the connection pool thread.
   */
  fun cancel()

  /**

            response
              .newBuilder()
              .body(responseBody)
              .trailers(
                object : TrailersSource {
                  override fun peek() = exchange.peekTrailers()

                  override fun get(): Headers {
                    val source = responseBody.source()
                    if (source.isOpen) {
                      source.skipAll()
                    }