Class ProgressController

packages/playwright-core/src/server/progress.ts:28–144

export type { Progress } from '@protocol/progress';

export class ProgressController {
  private _forceAbortPromise = new ManualPromise<any>();
  private _donePromise = new ManualPromise<void>();
  private _state: 'before' | 'running' | { error: Error } | 'finished' = 'before';
  private _onCallLog?: (message: string) => void;

  readonly metadata: CallMetadata;
  private _controller: AbortController;

  constructor(metadata?: CallMetadata, onCallLog?: (message: string) => void) {
    this.metadata = metadata || { id: '', startTime: 0, endTime: 0, type: 'Internal', method: '', params: {}, log: [], internal: true };
    this._onCallLog = onCallLog;
    this._forceAbortPromise.catch(e => null);  // Prevent unhandled promise rejection.
    this._controller = new AbortController();
  }

  static createForSdkObject(sdkObject: SdkObject, callMetadata: CallMetadata) {
    const logName = sdkObject.logName || 'api';
    return new ProgressController(callMetadata, message => {
      // Note: "attribution.playwright" is undefined in DebugController. Unfortunate!
      if (logName === 'api' && sdkObject.attribution.playwright?.options.isInternalPlaywright)
        return;
      debugLogger.log(logName, message);
      sdkObject.instrumentation.onCallLog(sdkObject, callMetadata, logName, message);
    });
  }


  async abort(error: Error) {
    if (this._state === 'running') {
      (error as any)[kAbortErrorSymbol] = true;
      this._state = { error };
      this._forceAbortPromise.reject(error);
      this._controller.abort(error);
    }
    await this._donePromise;
  }

  async run<T>(task: (progress: Progress) => Promise<T>, timeout?: number): Promise<T> {
    const deadline = timeout ? monotonicTime() + timeout : 0;
    assert(this._state === 'before');
    this._state = 'running';
    let timer: NodeJS.Timeout | undefined;

    let outerProgress: string | undefined;
    let allowConcurrent = false;

    const progress: Progress = {
      timeout: timeout ?? 0,
      deadline,
      disableTimeout: () => {
        clearTimeout(timer);
      },
      log: message => {
        if (this._state === 'running')
          this.metadata.log.push(message);
        // Note: we might be sending logs after progress has finished, for example browser logs.
        this._onCallLog?.(message);