chore: conditionally dispatch network events

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

@@ -96,6 +96,13 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
     this._channel.on('requestFinished', params => this._onRequestFinished(params));
     this._channel.on('response', ({ response, page }) => this._onResponse(network.Response.from(response), Page.fromNullable(page)));
     this._closedPromise = new Promise(f => this.once(Events.BrowserContext.Close, f));
+
+    this._setEventToSubscriptionMapping(new Map<string, channels.BrowserContextUpdateSubscriptionParams['event']>([
+      [Events.BrowserContext.Request, 'request'],
+      [Events.BrowserContext.Response, 'response'],
+      [Events.BrowserContext.RequestFinished, 'requestFinished'],
+      [Events.BrowserContext.RequestFailed, 'requestFailed'],
+    ]));
   }
 
   _setBrowserType(browserType: BrowserType) {

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

@@ -26,6 +26,8 @@ import type { ClientInstrumentation } from './clientInstrumentation';
 import type { Connection } from './connection';
 import type { Logger } from './types';
 
+type Listener = (...args: any[]) => void;
+
 export abstract class ChannelOwner<T extends channels.Channel = channels.Channel> extends EventEmitter {
   readonly _connection: Connection;
   private _parent: ChannelOwner | undefined;
@@ -37,6 +39,7 @@ export abstract class ChannelOwner<T extends channels.Channel = channels.Channel
   readonly _initializer: channels.InitializerTraits<T>;
   _logger: Logger | undefined;
   _instrumentation: ClientInstrumentation | undefined;
+  private _eventToSubscriptionMapping: Map<string, string> = new Map();
 
   constructor(parent: ChannelOwner | Connection, type: string, guid: string, initializer: channels.InitializerTraits<T>, instrumentation?: ClientInstrumentation) {
     super();
@@ -57,6 +60,51 @@ export abstract class ChannelOwner<T extends channels.Channel = channels.Channel
     this._initializer = initializer;
   }
 
+  _setEventToSubscriptionMapping(mapping: Map<string, string>) {
+    this._eventToSubscriptionMapping = mapping;
+  }
+
+  private _updateSubscription(event: string | symbol, enabled: boolean) {
+    const protocolEvent = this._eventToSubscriptionMapping.get(String(event));
+    if (protocolEvent)
+      (this._channel as any).updateSubscription({ event: protocolEvent, enabled }).catch(() => {});
+  }
+
+  override on(event: string | symbol, listener: Listener): this {
+    if (!this.listenerCount(event))
+      this._updateSubscription(event, true);
+    super.on(event, listener);
+    return this;
+  }
+
+  override addListener(event: string | symbol, listener: Listener): this {
+    if (!this.listenerCount(event))
+      this._updateSubscription(event, true);
+    super.addListener(event, listener);
+    return this;
+  }
+
+  override prependListener(event: string | symbol, listener: Listener): this {
+    if (!this.listenerCount(event))
+      this._updateSubscription(event, true);
+    super.prependListener(event, listener);
+    return this;
+  }
+
+  override off(event: string | symbol, listener: Listener): this {
+    super.off(event, listener);
+    if (!this.listenerCount(event))
+      this._updateSubscription(event, false);
+    return this;
+  }
+
+  override removeListener(event: string | symbol, listener: Listener): this {
+    super.removeListener(event, listener);
+    if (!this.listenerCount(event))
+      this._updateSubscription(event, false);
+    return this;
+  }
+
   _adopt(child: ChannelOwner<any>) {
     child._parent!._objects.delete(child._guid);
     this._objects.set(child._guid, child);

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

@@ -66,7 +66,6 @@ type PDFOptions = Omit<channels.PagePdfParams, 'width' | 'height' | 'margin'> &
   },
   path?: string,
 };
-type Listener = (...args: any[]) => void;
 
 type ExpectScreenshotOptions = Omit<channels.PageExpectScreenshotOptions, 'screenshotOptions' | 'locator' | 'expected'> & {
   expected?: Buffer,
@@ -161,6 +160,14 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
       new Promise<void>(f => this.once(Events.Page.Close, f)),
       new Promise<void>(f => this.once(Events.Page.Crash, f)),
     ]);
+
+    this._setEventToSubscriptionMapping(new Map<string, channels.PageUpdateSubscriptionParams['event']>([
+      [Events.Page.Request, 'request'],
+      [Events.Page.Response, 'response'],
+      [Events.Page.RequestFinished, 'requestFinished'],
+      [Events.Page.RequestFailed, 'requestFailed'],
+      [Events.Page.FileChooser, 'fileChooser'],
+    ]));
   }
 
   private _onFrameAttached(frame: Frame) {
@@ -693,41 +700,6 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
     return [...this._workers];
   }
 
-  override on(event: string | symbol, listener: Listener): this {
-    if (event === Events.Page.FileChooser && !this.listenerCount(event))
-      this._channel.setFileChooserInterceptedNoReply({ intercepted: true });
-    super.on(event, listener);
-    return this;
-  }
-
-  override addListener(event: string | symbol, listener: Listener): this {
-    if (event === Events.Page.FileChooser && !this.listenerCount(event))
-      this._channel.setFileChooserInterceptedNoReply({ intercepted: true });
-    super.addListener(event, listener);
-    return this;
-  }
-
-  override prependListener(event: string | symbol, listener: Listener): this {
-    if (event === Events.Page.FileChooser && !this.listenerCount(event))
-      this._channel.setFileChooserInterceptedNoReply({ intercepted: true });
-    super.prependListener(event, listener);
-    return this;
-  }
-
-  override off(event: string | symbol, listener: Listener): this {
-    super.off(event, listener);
-    if (event === Events.Page.FileChooser && !this.listenerCount(event))
-      this._channel.setFileChooserInterceptedNoReply({ intercepted: false });
-    return this;
-  }
-
-  override removeListener(event: string | symbol, listener: Listener): this {
-    super.removeListener(event, listener);
-    if (event === Events.Page.FileChooser && !this.listenerCount(event))
-      this._channel.setFileChooserInterceptedNoReply({ intercepted: false });
-    return this;
-  }
-
   async pause() {
     if (!require('inspector').url())
       await this.context()._channel.pause();

packages/playwright-core/src/protocol/validator.ts

@@ -869,6 +869,11 @@ scheme.BrowserContextCreateTempFileParams = tObject({
 scheme.BrowserContextCreateTempFileResult = tObject({
   writableStream: tChannel(['WritableStream']),
 });
+scheme.BrowserContextUpdateSubscriptionParams = tObject({
+  event: tEnum(['request', 'response', 'requestFinished', 'requestFailed']),
+  enabled: tBoolean,
+});
+scheme.BrowserContextUpdateSubscriptionResult = tOptional(tObject({}));
 scheme.PageInitializer = tObject({
   mainFrame: tChannel(['Frame']),
   viewportSize: tOptional(tObject({
@@ -927,10 +932,6 @@ scheme.PageSetDefaultTimeoutNoReplyParams = tObject({
   timeout: tOptional(tNumber),
 });
 scheme.PageSetDefaultTimeoutNoReplyResult = tOptional(tObject({}));
-scheme.PageSetFileChooserInterceptedNoReplyParams = tObject({
-  intercepted: tBoolean,
-});
-scheme.PageSetFileChooserInterceptedNoReplyResult = tOptional(tObject({}));
 scheme.PageAddInitScriptParams = tObject({
   source: tString,
 });
@@ -1162,6 +1163,11 @@ scheme.PageStopCSSCoverageResult = tObject({
 });
 scheme.PageBringToFrontParams = tOptional(tObject({}));
 scheme.PageBringToFrontResult = tOptional(tObject({}));
+scheme.PageUpdateSubscriptionParams = tObject({
+  event: tEnum(['fileChooser', 'request', 'response', 'requestFinished', 'requestFailed']),
+  enabled: tBoolean,
+});
+scheme.PageUpdateSubscriptionResult = tOptional(tObject({}));
 scheme.FrameInitializer = tObject({
   url: tString,
   name: tString,

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

@@ -15,7 +15,7 @@
  */
 
 import type * as channels from '@protocol/channels';
-import { Dispatcher } from './dispatcher';
+import { Dispatcher, existingDispatcher } from './dispatcher';
 import type { DispatcherScope } from './dispatcher';
 import { StreamDispatcher } from './streamDispatcher';
 import fs from 'fs';
@@ -24,7 +24,19 @@ import type { Artifact } from '../artifact';
 
 export class ArtifactDispatcher extends Dispatcher<Artifact, channels.ArtifactChannel, DispatcherScope> implements channels.ArtifactChannel {
   _type_Artifact = true;
-  constructor(scope: DispatcherScope, artifact: Artifact) {
+
+  static from(parentScope: DispatcherScope, artifact: Artifact): ArtifactDispatcher {
+    return ArtifactDispatcher.fromNullable(parentScope, artifact)!;
+  }
+
+  static fromNullable(parentScope: DispatcherScope, artifact: Artifact): ArtifactDispatcher | undefined {
+    if (!artifact)
+      return undefined;
+    const result = existingDispatcher<ArtifactDispatcher>(artifact);
+    return result || new ArtifactDispatcher(parentScope, artifact);
+  }
+
+  private constructor(scope: DispatcherScope, artifact: Artifact) {
     super(scope, artifact, 'Artifact', {
       absolutePath: artifact.localPath(),
     });

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

@@ -15,7 +15,7 @@
  */
 
 import { BrowserContext } from '../browserContext';
-import { Dispatcher, lookupDispatcher } from './dispatcher';
+import { Dispatcher, existingDispatcher } from './dispatcher';
 import type { DispatcherScope } from './dispatcher';
 import { PageDispatcher, BindingCallDispatcher, WorkerDispatcher } from './pageDispatcher';
 import type { FrameDispatcher } from './frameDispatcher';
@@ -38,6 +38,7 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
   _type_EventTarget = true;
   _type_BrowserContext = true;
   private _context: BrowserContext;
+  private _subscriptions = new Set<channels.BrowserContextUpdateSubscriptionParams['event']>();
 
   constructor(parentScope: DispatcherScope, context: BrowserContext) {
     // We will reparent these to the context below.
@@ -60,7 +61,7 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
     const onVideo = (artifact: Artifact) => {
       // Note: Video must outlive Page and BrowserContext, so that client can saveAs it
       // after closing the context. We use |scope| for it.
-      const artifactDispatcher = new ArtifactDispatcher(parentScope, artifact);
+      const artifactDispatcher = ArtifactDispatcher.from(parentScope, artifact);
       this._dispatchEvent('video', { artifact: artifactDispatcher });
     };
     this.addObjectListener(BrowserContext.Events.VideoStarted, onVideo);
@@ -88,27 +89,56 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
       this.addObjectListener(CRBrowserContext.CREvents.ServiceWorker, serviceWorker => this._dispatchEvent('serviceWorker', { worker: new WorkerDispatcher(this, serviceWorker) }));
     }
     this.addObjectListener(BrowserContext.Events.Request, (request: Request) =>  {
-      return this._dispatchEvent('request', {
+      const redirectFromDispatcher = request.redirectedFrom() && existingDispatcher(request.redirectedFrom());
+      if (!redirectFromDispatcher && !this._shouldDispatchNetworkEvent(request, 'request'))
+        return;
+      const requestDispatcher = RequestDispatcher.from(this, request);
+      this._dispatchEvent('request', {
+        request: requestDispatcher,
+        page: PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined())
+      });
+    });
+    this.addObjectListener(BrowserContext.Events.Response, (response: Response) => {
+      const requestDispatcher = existingDispatcher<RequestDispatcher>(response.request());
+      if (!requestDispatcher && !this._shouldDispatchNetworkEvent(response.request(), 'response'))
+        return;
+      this._dispatchEvent('response', {
+        response: ResponseDispatcher.from(this, response),
+        page: PageDispatcher.fromNullable(this, response.frame()?._page.initializedOrUndefined())
+      });
+    });
+    this.addObjectListener(BrowserContext.Events.RequestFailed, (request: Request) => {
+      const requestDispatcher = existingDispatcher<RequestDispatcher>(request);
+      if (!requestDispatcher && !this._shouldDispatchNetworkEvent(request, 'requestFailed'))
+        return;
+      this._dispatchEvent('requestFailed', {
         request: RequestDispatcher.from(this, request),
+        failureText: request._failureText || undefined,
+        responseEndTiming: request._responseEndTiming,
         page: PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined())
       });
     });
-    this.addObjectListener(BrowserContext.Events.Response, (response: Response) => this._dispatchEvent('response', {
-      response: ResponseDispatcher.from(this, response),
-      page: PageDispatcher.fromNullable(this, response.frame()?._page.initializedOrUndefined())
-    }));
-    this.addObjectListener(BrowserContext.Events.RequestFailed, (request: Request) => this._dispatchEvent('requestFailed', {
-      request: RequestDispatcher.from(this, request),
-      failureText: request._failureText || undefined,
-      responseEndTiming: request._responseEndTiming,
-      page: PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined())
-    }));
-    this.addObjectListener(BrowserContext.Events.RequestFinished, ({ request, response }: { request: Request, response: Response | null }) => this._dispatchEvent('requestFinished', {
-      request: RequestDispatcher.from(this, request),
-      response: ResponseDispatcher.fromNullable(this, response),
-      responseEndTiming: request._responseEndTiming,
-      page: PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined()),
-    }));
+    this.addObjectListener(BrowserContext.Events.RequestFinished, ({ request, response }: { request: Request, response: Response | null }) => {
+      const requestDispatcher = existingDispatcher<RequestDispatcher>(request);
+      if (!requestDispatcher && !this._shouldDispatchNetworkEvent(request, 'requestFinished'))
+        return;
+      this._dispatchEvent('requestFinished', {
+        request: RequestDispatcher.from(this, request),
+        response: ResponseDispatcher.fromNullable(this, response),
+        responseEndTiming: request._responseEndTiming,
+        page: PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined()),
+      });
+    });
+  }
+
+  private _shouldDispatchNetworkEvent(request: Request, event: channels.BrowserContextUpdateSubscriptionParams['event'] & channels.PageUpdateSubscriptionParams['event']): boolean {
+    if (this._subscriptions.has(event))
+      return true;
+    const page = request.frame()?._page?.initializedOrUndefined();
+    const pageDispatcher = page ? existingDispatcher<PageDispatcher>(page) : undefined;
+    if (pageDispatcher?._subscriptions.has(event))
+      return true;
+    return false;
   }
 
   async createTempFile(params: channels.BrowserContextCreateTempFileParams, metadata?: channels.Metadata): Promise<channels.BrowserContextCreateTempFileResult> {
@@ -138,7 +168,7 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
   }
 
   async newPage(params: channels.BrowserContextNewPageParams, metadata: CallMetadata): Promise<channels.BrowserContextNewPageResult> {
-    return { page: lookupDispatcher<PageDispatcher>(await this._context.newPage(metadata)) };
+    return { page: PageDispatcher.from(this, await this._context.newPage(metadata)) };
   }
 
   async cookies(params: channels.BrowserContextCookiesParams): Promise<channels.BrowserContextCookiesResult> {
@@ -225,7 +255,14 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
     const artifact = await this._context._harExport(params.harId);
     if (!artifact)
       throw new Error('No HAR artifact. Ensure record.harPath is set.');
-    return { artifact: new ArtifactDispatcher(this, artifact) };
+    return { artifact: ArtifactDispatcher.from(this, artifact) };
+  }
+
+  async updateSubscription(params: channels.BrowserContextUpdateSubscriptionParams, metadata?: channels.Metadata | undefined): Promise<void> {
+    if (params.enabled)
+      this._subscriptions.add(params.event);
+    else
+      this._subscriptions.delete(params.event);
   }
 
   override _dispose() {

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

@@ -18,7 +18,7 @@ import { EventEmitter } from 'events';
 import type * as channels from '@protocol/channels';
 import { serializeError } from '../../protocol/serializers';
 import { findValidator, ValidationError, createMetadataValidator, type ValidatorContext } from '../../protocol/validator';
-import { assert, debugAssert, isUnderTest, monotonicTime } from '../../utils';
+import { assert, isUnderTest, monotonicTime } from '../../utils';
 import { kBrowserOrContextClosedError } from '../../common/errors';
 import type { CallMetadata } from '../instrumentation';
 import { SdkObject } from '../instrumentation';
@@ -30,20 +30,10 @@ import type { RegisteredListener } from '../..//utils/eventsHelper';
 export const dispatcherSymbol = Symbol('dispatcher');
 const metadataValidator = createMetadataValidator();
 
-export function lookupDispatcher<DispatcherType>(object: any): DispatcherType {
-  const result = object[dispatcherSymbol];
-  debugAssert(result);
-  return result;
-}
-
-export function existingDispatcher<DispatcherType>(object: any): DispatcherType {
+export function existingDispatcher<DispatcherType>(object: any): DispatcherType | undefined {
   return object[dispatcherSymbol];
 }
 
-export function lookupNullableDispatcher<DispatcherType>(object: any | null): DispatcherType | undefined {
-  return object ? lookupDispatcher(object) : undefined;
-}
-
 export class Dispatcher<Type extends { guid: string }, ChannelType, ParentScopeType extends DispatcherScope> extends EventEmitter implements channels.Channel {
   private _connection: DispatcherConnection;
   // Parent is always "isScope".