TF_LOCKS_EXCLUDED(mu_);
  bool AllowsSyncOnCompletion() const override TF_LOCKS_EXCLUDED(mu_);

  // Installs an error handling callback when RefreshStatus sees !status.ok().
  void SetHandleDeviceErrorCallback(std::function<Status()> callback);

  Status RefreshStatus() override TF_LOCKS_EXCLUDED(mu_);

 private:
  absl::StatusOr<xla::LocalClient*> GetOrCreateClient() const;

  streams_defined_on_ = {stream};
}

Status XlaTensor::RefreshStatusOfStreams() {
  mutex_lock lock(mu_);
  Status status;
  for (se::Stream* stream : streams_defined_on_) {
    status.Update(stream->RefreshStatus());
  }
  return status;
}

// The pointer tag, OR-ed into the XlaTensor's address to distinguish it from
// device-side tensors, which are either CPU or GPU memory pointers. This works

    }
  };

  StreamExecutor* executor = GetExecutor(0);
  TF_ASSERT_OK_AND_ASSIGN(auto stream, executor->CreateStream());
  TF_ASSERT_OK(stream->RefreshStatus());
  status_ok = false;
  auto updated_status = stream->RefreshStatus();
  ASSERT_FALSE(stream->ok());
  ASSERT_EQ(updated_status.message(), "Test error");
}

TEST_F(StreamExecutorTest, CreateEvent) {
  static bool event_created = false;

    return s;
  }

  void Destroy() {
    if (stream_handle_ != nullptr) {
      stream_executor_->destroy_stream(device_, stream_handle_);
      stream_handle_ = nullptr;
    }
  }
  absl::Status RefreshStatus() override {
    tensorflow::TF_StatusPtr c_status(TF_NewStatus());
    stream_executor_->get_stream_status(device_, stream_handle_,
                                        c_status.get());

    return local_device_error_callback();
  }
  return absl::OkStatus();
}

Status XlaDevice::RefreshStatus() {
  std::shared_ptr<se::Stream> stream;
  {
    mutex_lock lock(mu_);
    stream = stream_;
  }
  if (!stream) {
    return absl::OkStatus();
  }
  Status status = stream->RefreshStatus();
  if (!status.ok()) {
    // Ignore errors from HandleDeviceError, since by definition the status is

        // on some platforms. Releasing it in another stream to avoid that.
        if (!device_allows_sync_on_completion &&
            !device_to_host_stream->RefreshStatus().ok()) {
          auto status_or_new_stream = client_->mutable_backend()->BorrowStream(
              stream_->parent()->device_ordinal());
          if (status_or_new_stream.ok()) {