Silent failure when ProgressIndicator cancellation is caught and not rethrown

Direct Answer

Catch ProcessCanceledException, perform cleanup in a finally block (or after the catch), then rethrow the exception. This is the only pattern that guarantees the platform updates the UI, logs the cancellation, and notifies dependent tasks. Swallowing the exception—even in a generic catch (Exception e)—causes silent failure.

Safe Cleanup Patterns

1. Finally-Block Rethrow (Recommended)

try {
    // cancellable work
    ProgressManager.checkCanceled(); // throws if cancelled
} finally {
    cleanup(); // runs on both success and cancellation
    ProgressManager.checkCanceled(); // rethrows if cancellation occurred
}

The second checkCanceled() ensures the exception propagates after cleanup finishes.

2. Explicit Catch-and-Rethrow

try {
    doWork();
} catch (ProcessCanceledException e) {
    cleanup();
    throw e; // must rethrow
}

Use this when cleanup logic differs between success and cancellation paths.

3. Utility Helper for Repeated Use

static void runWithCleanup(Runnable work, Runnable cleanup) {
    try {
        work.run();
    } finally {
        cleanup.run();
        ProgressManager.checkCanceled();
    }
}

Call as runWithCleanup(this::doWork, this::cleanup);.

Platform-Provided Helpers

• Task.Backgroundable / Task.Modal — override run(@NotNull ProgressIndicator) and onCancel(). The framework calls onCancel() after the task thread is interrupted and before the exception propagates, so you get cleanup without manual rethrow.
• BackgroundableTaskQueue — enqueue Runnables; the queue handles cancellation and invokes your done() callback on both completion and cancellation.
• ProgressIndicator.runWithProgressSynchronously() — for modal tasks; it rethrows ProcessCanceledException automatically after the block exits.

Verification Steps

1. Log before and after the catch/finally block. After a user-initiated cancel, the log must show the exception rethrown (stack trace or explicit log line).
2. UI check. Cancel the task from the progress dialog. The dialog should close or show a cancelled state; it must not remain stuck at the last fraction.
3. Programmatic assertion. Immediately after the cleanup block, assert ProgressManager.getInstance().getProgressIndicator().isCanceled() == true when cancellation was requested.

Common Pitfalls

• Catching Exception or Throwable and not rethrowing ProcessCanceledException.
• Long-running or blocking cleanup inside the catch block without checking Thread.interrupted() or the indicator, which delays UI updates.
• Non-idempotent cleanup that breaks if run twice (normal completion + cancellation).

One Diagnostic Detail

Are you implementing a Task.Backgroundable subclass, a plain Runnable passed to ProgressManager.getInstance().run(), or a custom ProgressIndicator consumer? The exact API changes which helper (onCancel() vs. manual rethrow) is most natural.