inFinished: Boolean,
      streamId: Int,
      source: BufferedSource,
      length: Int,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_DATA
      this.inFinished = inFinished
      this.streamId = streamId
      this.data = source.readByteString(length.toLong()).toByteArray()
    }

    override fun rstStream(
      streamId: Int,
      errorCode: ErrorCode,
    ) {

   *
   * ```
   * direction streamID length type flags
   * ```
   *
   * Where direction is `<<` for inbound and `>>` for outbound.
   *
   * For example, the following would indicate a HEAD request sent from the client.
   * ```
   * `<< 0x0000000f    12 HEADERS       END_HEADERS|END_STREAM
   * ```
   */
  fun frameLog(
    inbound: Boolean,
    streamId: Int,
    length: Int,
    type: Int,

  val start = System.currentTimeMillis()

  override fun receivingStreamWindowChanged(
    streamId: Int,
    windowCounter: WindowCounter,
    bufferSize: Long,
  ) {
    println("${System.currentTimeMillis() - start},$streamId,${windowCounter.unacknowledged},$bufferSize")
  }

  override fun receivingConnectionWindowChanged(windowCounter: WindowCounter) {

    check(acknowledged >= 0)

    this.total += total
    this.acknowledged += acknowledged

    check(this.acknowledged <= this.total)
  }

  override fun toString(): String {
    return "WindowCounter(streamId=$streamId, total=$total, acknowledged=$acknowledged, unacknowledged=$unacknowledged)"
  }

    }

    @Synchronized override fun onRequest(
      streamId: Int,
      requestHeaders: List<Header>,
    ): Boolean {
      assertThat(streamId).isEqualTo(2)
      events.add(requestHeaders)
      notifyAll()
      return false
    }

    @Synchronized override fun onHeaders(
      streamId: Int,
      responseHeaders: List<Header>,
      last: Boolean,
    ): Boolean {

  /**
   * Notification that the receiving stream flow control window has changed.
   * [WindowCounter] generally carries the client view of total and acked bytes.
   */
  fun receivingStreamWindowChanged(
    streamId: Int,
    windowCounter: WindowCounter,
    bufferSize: Long,
  )

  /**
   * Notification that the receiving connection flow control window has changed.

  public final String team_name;
  public final String team_id;

  public OAuthSession(
      boolean ok, String accessToken, String scope, String userId, String teamName, String teamId) {
    this.ok = ok;
    this.access_token = accessToken;
    this.scope = scope;
    this.user_id = userId;
    this.team_name = teamName;
    this.team_id = teamId;
  }

  @Override public String toString() {

  auto status = stream_->Memcpy(device_memory_base_, cpu_tensor->data(),
                                device_memory_base_->size());
  if (!status.ok()) {
    done(status);
    return;
  }
  status = stream_->RecordEvent(done_event_.get().get());
  if (!status.ok()) {
    done(status);
    return;
  }
  if (auto st = stream_->BlockHostUntilDone(); !st.ok()) {

  *cpu_tensor = Tensor(dtype, tensor_shape);

  status = stream_->Memcpy(cpu_tensor->data(), device_memory_base_,
                           device_memory_base_.size());
  if (!status.ok()) {
    done(status);
    return;
  }
  status = stream_->RecordEvent(done_event_.get().get());
  if (!status.ok()) {
    done(status);
    return;
  }
  if (auto st = stream_->BlockHostUntilDone(); !st.ok()) {

    if (UseMultipleStreams() &&
        !transfer_manager_->CanShapedBufferBeAccessedNow(
            stream_->parent(), xla_tensor->shaped_buffer())) {
      // Initially wait for the compute stream so that memory allocations are
      // synchronized.
      TF_RETURN_IF_ERROR(host_to_device_stream_->WaitFor(stream_.get()));
    }

    TF_RETURN_IF_ERROR(transfer_manager_->TransferLiteralToDeviceAsync(