}

  override fun writeTimeoutMillis(): Int = writeTimeoutMillis

  override fun withWriteTimeout(
    timeout: Int,
    unit: TimeUnit,
  ): Interceptor.Chain {
    check(exchange == null) { "Timeouts can't be adjusted in a network interceptor" }

    return copy(writeTimeoutMillis = checkDuration("writeTimeout", timeout.toLong(), unit))
  }

    return RealRoutePlanner(
      taskRunner = client.taskRunner,
      connectionPool = client.connectionPool.delegate,
      readTimeoutMillis = client.readTimeoutMillis,
      writeTimeoutMillis = client.writeTimeoutMillis,
      socketConnectTimeoutMillis = chain.connectTimeoutMillis,
      socketReadTimeoutMillis = chain.readTimeoutMillis,
      pingIntervalMillis = client.pingIntervalMillis,

          ForceConnectRoutePlanner(
            RealRoutePlanner(
              taskRunner = taskRunner,
              connectionPool = pool,
              readTimeoutMillis = readTimeoutMillis,
              writeTimeoutMillis = writeTimeoutMillis,
              socketConnectTimeoutMillis = socketConnectTimeoutMillis,
              socketReadTimeoutMillis = socketReadTimeoutMillis,
              pingIntervalMillis = pingIntervalMillis,

      timeout: Int,
      unit: TimeUnit,
    ): Chain

    fun readTimeoutMillis(): Int

    fun withReadTimeout(
      timeout: Int,
      unit: TimeUnit,
    ): Chain

    fun writeTimeoutMillis(): Int

    fun withWriteTimeout(
      timeout: Int,
      unit: TimeUnit,
    ): Chain
  }

      stream!!.closeLater(ErrorCode.CANCEL)
      throw IOException("Canceled")
    }
    stream!!.readTimeout().timeout(chain.readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
    stream!!.writeTimeout().timeout(chain.writeTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
  }

  override fun flushRequest() {
    http2Connection.flush()
  }

  override fun finishRequest() {
    stream!!.sink.close()
  }