Function timedWait

src/processrunner.cpp:218–282

waits for completion, times out after `wait` if not Infinite

// waits for completion, times out after `wait` if not Infinite
//
std::optional<ProcessRunner::Results> timedWait(HANDLE handle, DWORD pid,
                                                UILocker::Session* ls,
                                                std::chrono::milliseconds wait,
                                                std::atomic<bool>& interrupt)
{
  using namespace std::chrono;

  high_resolution_clock::time_point start;
  if (wait != Infinite) {
    start = high_resolution_clock::now();
  }

  while (!interrupt) {
    // wait for a very short while, allows for processing events below
    const auto r = singleWait(handle, pid);

    if (r) {
      // the process has either completed or an error was returned
      return *r;
    }

    // the process is still running

    // check the lock widget; the session can be null when running shortcuts
    // with locking disabled, in which case the user cannot force unlock
    if (ls) {
      switch (ls->result()) {
      case UILocker::StillLocked: {
        break;
      }

      case UILocker::ForceUnlocked: {
        log::debug("waiting for {} force unlocked by user", pid);
        return ProcessRunner::ForceUnlocked;
      }

      case UILocker::Cancelled: {
        log::debug("waiting for {} cancelled by user", pid);
        return ProcessRunner::Cancelled;
      }

      case UILocker::NoResult:  // fall-through
      default: {
        // shouldn't happen
        log::debug("unexpected result {} while waiting for {}",
                   static_cast<int>(ls->result()), pid);

        return ProcessRunner::Error;
      }
      }
    }

    if (wait != Infinite) {
      // check if enough time has elapsed
      const auto now = high_resolution_clock::now();
      if (duration_cast<milliseconds>(now - start) >= wait) {
        // if so, return an empty result
        return {};