socket.sink.writeUtf8(response.status)
    socket.sink.writeUtf8("\r\n")

    writeHeaders(socket.sink, response.headers)

    if (response.socketHandler != null) {
      response.socketHandler.handle(socket)
      return
    }

    val body = response.body ?: return
    socket.sleepWhileOpen(response.bodyDelayNanos)
    val responseBodySink =
      socket.sink

  }

  override fun flushRequest() {
    socket.sink.flush()
  }

  override fun finishRequest() {
    socket.sink.flush()
  }

  /** Returns bytes of a request header for sending on an HTTP transport. */
  fun writeRequest(
    headers: Headers,
    requestLine: String,
  ) {
    check(state == STATE_IDLE) { "state: $state" }
    socket.sink.writeUtf8(requestLine).writeUtf8("\r\n")

      )
    assertThat(tlsSpec.isCompatible(socket)).isTrue()
    applyConnectionSpec(tlsSpec, socket, isFallback = false)
    assertThat(socket.enabledProtocols).containsExactly(
      TlsVersion.TLS_1_2.javaName,
    )
    assertThat(socket.enabledCipherSuites.toList())
      .containsExactlyInAnyOrder(
        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.javaName,

        Http1ExchangeCodec(
          // No client for CONNECT tunnels:
          client = null,
          carrier = this,
          socket = socket,
        )
      socket.source.timeout().timeout(readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
      socket.sink.timeout().timeout(writeTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
      tunnelCodec.writeRequest(nextRequest.headers, requestLine)

  override val route: Route,
  /** The low-level TCP socket. */
  private val rawSocket: JavaNetSocket,
  /**
   * The application layer socket. Either an [SSLSocket] layered over [rawSocket], or [rawSocket]
   * itself if this connection does not use SSL.
   */
  private val javaNetSocket: JavaNetSocket,
  private val handshake: Handshake?,
  private val protocol: Protocol,
  private val socket: BufferedSocket,

        this.headers = headers.newBuilder()
      }

    open fun body(body: ResponseBody) =
      apply {
        this.body = body
      }

    open fun socket(socket: Socket) =
      apply {
        this.socket = socket
      }

    open fun networkResponse(networkResponse: Response?) =
      apply {
        checkSupportResponse("networkResponse", networkResponse)

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

    return object : Socket {
      override fun cancel() {
        ******@****.***()
      }

      override val sink =
        RequestBodySink(
          delegate = codec.socket.sink,
          contentLength = -1L,
          isSocket = true,
        )

  }

  /**
   * Returns `true` if the socket, as currently configured, supports this connection spec. In
   * order for a socket to be compatible the enabled cipher suites and protocols must intersect.
   *
   * For cipher suites, at least one of the [required cipher suites][cipherSuites] must match the
   * socket's enabled cipher suites. If there are no required cipher suites the socket must have at
   * least one cipher suite enabled.

 * attempting to read with a short timeout. If the fails immediately we know the socket is
 * unhealthy.
 *
 * @param source the source used to read bytes from the socket.
 */
internal fun Socket.isHealthy(source: BufferedSource): Boolean =
  try {
    val readTimeout = soTimeout
    try {
      soTimeout = 1
      !source.exhausted()

  var writeBytesMaximum: Long = peerSettings.initialWindowSize.toLong()
    private set

  internal val socket: BufferedSocket = builder.socket
  val writer = Http2Writer(socket.sink, client)

  // Visible for testing
  val readerRunnable = ReaderRunnable(Http2Reader(socket.source, client))

  // Guarded by this.
  private val currentPushRequests = mutableSetOf<Int>()

  init {