Logging unhandled dialog

packages/playwright-core/src/client/browser.ts

@@ -86,6 +86,8 @@ export class Browser extends ChannelOwner<channels.BrowserChannel> implements ap
       context._forReuse = true;
     if (options.logger)
       context._logger = options.logger;
+    if (options.unhandledDialogCallback)
+      context._unhandledDialogCallback = options.unhandledDialogCallback;
     await context._initializeHarFromOptions(options.recordHar);
     await this._instrumentation.runAfterCreateBrowserContext(context);
     return context;

packages/playwright-core/src/client/browserContext.ts

@@ -65,6 +65,8 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
   _timeoutSettings: TimeoutSettings;
   _ownerPage: Page | undefined;
   _forReuse = false;
+  _unhandledDialogCallback: ((dialog: Dialog) => void) | undefined;
+
   private _closedPromise: Promise<void>;
   readonly _options: channels.BrowserNewContextParams;
 

packages/playwright-core/src/client/types.ts

@@ -84,6 +84,7 @@ export type BrowserContextOptions = Omit<channels.BrowserNewContextOptions, 'vie
   contrast?: 'more' | 'no-preference' | null;
   acceptDownloads?: boolean;
   clientCertificates?: ClientCertificate[];
+  unhandledDialogCallback?: (dialog: import('./dialog').Dialog) => void;
 };
 
 type LaunchOverrides = {

packages/playwright-core/src/server/browserContext.ts

@@ -109,7 +109,7 @@ export abstract class BrowserContext extends SdkObject {
     this.fetchRequest = new BrowserContextAPIRequestContext(this);
     this.tracing = new Tracing(this, browser.options.tracesDir);
     this.clock = new Clock(this);
-    this.dialogManager = new DialogManager(this.instrumentation);
+    this.dialogManager = new DialogManager(this.instrumentation, this._options.unhandledDialogCallback);
   }
 
   isPersistentContext(): boolean {

packages/playwright-core/src/server/dialog.ts

@@ -82,11 +82,13 @@ export class Dialog extends SdkObject {
 
 export class DialogManager {
   private _instrumentation: Instrumentation;
+  private _unhandledDialogCallback?: (dialog: Dialog) => void;
   private _dialogHandlers = new Set<(dialog: Dialog) => boolean>();
   private _openedDialogs = new Set<Dialog>();
 
-  constructor(instrumentation: Instrumentation) {
+  constructor(instrumentation: Instrumentation, unhandledDialogCallback?: (dialog: Dialog) => void) {
     this._instrumentation = instrumentation;
+    this._unhandledDialogCallback = unhandledDialogCallback;
   }
 
   dialogDidOpen(dialog: Dialog) {
@@ -101,8 +103,11 @@ export class DialogManager {
       if (handler(dialog))
         hasHandlers = true;
     }
-    if (!hasHandlers)
+    if (!hasHandlers) {
+      if (this._unhandledDialogCallback)
+        this._unhandledDialogCallback(dialog);
       dialog.close().then(() => {});
+    }
   }
 
   dialogWillClose(dialog: Dialog) {

packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts

@@ -435,4 +435,4 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
       this._context.clock.resumeNoReply();
     this._clockPaused = false;
   }
-}
+}

packages/playwright-core/src/server/types.ts

@@ -160,6 +160,7 @@ export type LaunchOptions = Omit<channels.BrowserTypeLaunchParams, 'timeout'> &
 export type BrowserContextOptions = channels.BrowserNewContextOptions & {
   proxyOverride?: ProxySettings;
   internalIgnoreHTTPSErrors?: boolean;
+  unhandledDialogCallback?: (dialog: import('../server/dialog').Dialog) => void;
 };
 
 export type ProtocolLogger = (direction: 'send' | 'receive', message: object) => void;