Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.
TypeScript automationchromechromiume2e-testingelectronend-to-end-testingfirefoxjavascriptplaywrighttesttest-automationtestingtesting-toolswebwebkit
fix(workers): do not leak workers after closure (#41406)
Dmitry Gozmanfca6a5d12081
diff --git a/packages/playwright-core/src/server/chromium/crNetworkManager.ts b/packages/playwright-core/src/server/chromium/crNetworkManager.tsindex 9620171f92..e353798b03 100644--- a/packages/playwright-core/src/server/chromium/crNetworkManager.ts+++ b/packages/playwright-core/src/server/chromium/crNetworkManager.ts@@ -99,6 +99,8 @@ export class CRNetworkManager {if (info)eventsHelper.removeEventListeners(info.eventListeners);this._sessions.delete(session);+ for (const request of this._page?.networkRequests() ?? [])+ InterceptableRequest.detachIfNeeded(request, session);}private async _forEachSession(cb: (sessionInfo: SessionInfo) => Promise<any>) {@@ -377,32 +379,7 @@ export class CRNetworkManager {}_createResponse(request: InterceptableRequest, responsePayload: Protocol.Network.Response, hasExtraInfo: boolean): network.Response {- const getResponseBody = async () => {- const contentLengthHeader = Object.entries(responsePayload.headers).find(header => header[0].toLowerCase() === 'content-length');- const expectedLength = contentLengthHeader ? +contentLengthHeader[1] : undefined;-- const session = request.session;- const response = await session.send('Network.getResponseBody', { requestId: request._requestId });- if (response.body || !expectedLength)- return Buffer.from(response.body, response.base64Encoded ? 'base64' : 'utf8');-- // Make sure no network requests sent while reading the body for fulfilled requests.- if (request._originalRequestRoute?._fulfilled)- return Buffer.from('');-- // For <link prefetch we are going to receive empty body with non-empty content-length expectation. Reach out for the actual content.- const resource = await session.send('Network.loadNetworkResource', { url: request.request.url(), frameId: this._serviceWorker ? undefined : request.request.frame()!._id, options: { disableCache: false, includeCredentials: true } });- const chunks: Buffer[] = [];- while (resource.resource.stream) {- const chunk = await session.send('IO.read', { handle: resource.resource.stream });- chunks.push(Buffer.from(chunk.data, chunk.base64Encoded ? 'base64' : 'utf-8'));- if (chunk.eof) {- await session.send('IO.close', { handle: resource.resource.stream });- break;- }- }- return Buffer.concat(chunks);- };+ const getResponseBody = InterceptableRequest.createResponseBodyCallback(request.request);const timingPayload = responsePayload.timing!;let timing: network.ResourceTiming;if (timingPayload && !this._responseExtraInfoTracker.servedFromCache(request._requestId)) {@@ -577,6 +554,8 @@ export class CRNetworkManager {}}+const kInterceptableRequest = Symbol('InterceptableRequest');+class InterceptableRequest {readonly request: network.Request;readonly _requestId: string;@@ -589,6 +568,49 @@ class InterceptableRequest {readonly _originalRequestRoute: RouteImpl | undefined;session: CRSession;+ private static from(request: network.Request): InterceptableRequest | undefined {+ return (request as any)[kInterceptableRequest];+ }++ static detachIfNeeded(request: network.Request, session: CRSession) {+ if (InterceptableRequest.from(request)?.session === session)+ (request as any)[kInterceptableRequest] = undefined;+ }++ static createResponseBodyCallback(request: network.Request): () => Promise<Buffer> {+ return async () => {+ // Lookup the request lazily, so that the response does not retain the+ // InterceptableRequest and its session after detachIfNeeded().+ const interceptable = InterceptableRequest.from(request);+ if (!interceptable)+ throw new Error('Response body is unavailable');+ const contentLength = request._existingResponse()?.headerValue('content-length');+ const expectedLength = contentLength ? +contentLength : undefined;++ const session = interceptable.session;+ const response = await session.send('Network.getResponseBody', { requestId: interceptable._requestId });+ if (response.body || !expectedLength)+ return Buffer.from(response.body, response.base64Encoded ? 'base64' : 'utf8');++ // Make sure no network requests sent while reading the body for fulfilled requests.+ if (interceptable._originalRequestRoute?._fulfilled)+ return Buffer.from('');++ // For <link prefetch we are going to receive empty body with non-empty content-length expectation. Reach out for the actual content.+ const resource = await session.send('Network.loadNetworkResource', { url: request.url(), frameId: request.serviceWorker() ? undefined : request.frame()!._id, options: { disableCache: false, includeCredentials: true } });+ const chunks: Buffer[] = [];+ while (resource.resource.stream) {+ const chunk = await session.send('IO.read', { handle: resource.resource.stream });+ chunks.push(Buffer.from(chunk.data, chunk.base64Encoded ? 'base64' : 'utf-8'));+ if (chunk.eof) {+ await session.send('IO.close', { handle: resource.resource.stream });+ break;+ }+ }+ return Buffer.concat(chunks);+ };+ }+constructor(options: {session: CRSession,context: contexts.BrowserContext;@@ -622,6 +644,7 @@ class InterceptableRequest {postDataBuffer = Buffer.concat(entries.map(entry => Buffer.from(entry.bytes!, 'base64')));this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, toResourceType(requestWillBeSentEvent.type || 'Other'), method, postDataBuffer, headersOverride || headersObjectToArray(headers), requestWillBeSentEvent.wallTime * 1000);+ (this.request as any)[kInterceptableRequest] = this;}}diff --git a/packages/playwright-core/src/server/chromium/crPage.ts b/packages/playwright-core/src/server/chromium/crPage.tsindex 82139d2fac..40e6f98171 100644--- a/packages/playwright-core/src/server/chromium/crPage.ts+++ b/packages/playwright-core/src/server/chromium/crPage.ts@@ -757,6 +757,8 @@ class FrameSession {// This might be a worker...const workerSession = this._workerSessions.get(event.sessionId);if (workerSession) {+ this._workerSessions.delete(event.sessionId);+ this._crPage._networkManager.removeSession(workerSession);workerSession.dispose();this._page.removeWorker(event.sessionId);return;diff --git a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts b/packages/playwright-core/src/server/dispatchers/pageDispatcher.tsindex 531e168971..55f51723d2 100644--- a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts+++ b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts@@ -537,7 +537,10 @@ export class WorkerDispatcher extends Dispatcher<Worker, channels.WorkerChannel,timestamp: message.timestamp(),});});- this.addObjectListener(Worker.Events.Close, () => this._dispatchEvent('close'));+ this.addObjectListener(Worker.Events.Close, () => {+ this._dispatchEvent('close');+ this._dispose();+ });}async disconnect(params: channels.WorkerDisconnectParams, progress: Progress): Promise<void> {diff --git a/packages/playwright-core/src/server/index.ts b/packages/playwright-core/src/server/index.tsindex 194e618173..0dad0c0e6f 100644--- a/packages/playwright-core/src/server/index.ts+++ b/packages/playwright-core/src/server/index.ts@@ -21,8 +21,9 @@ export { deviceDescriptors } from './deviceDescriptors';export { DispatcherConnection, RootDispatcher, setMaxDispatchersForTest } from './dispatchers/dispatcher';export { RequestDispatcher, ResponseDispatcher } from './dispatchers/networkDispatchers';export { PlaywrightDispatcher } from './dispatchers/playwrightDispatcher';+export { PageDispatcher, WorkerDispatcher } from './dispatchers/pageDispatcher';export { Request, Response } from './network';-export { Page } from './page';+export { Page, Worker } from './page';export { createPlaywright } from './playwright';export { nullProgress } from './progress';export { WebSocketTransport } from './transport';diff --git a/tests/library/heap.spec.ts b/tests/library/heap.spec.tsindex 4c5a5e9a2d..15978d9dcc 100644--- a/tests/library/heap.spec.ts+++ b/tests/library/heap.spec.ts@@ -50,6 +50,91 @@ async function queryObjectCount(type: Function): Promise<number> {}}+// Debug helper that shows what exactly is retaining a given object type.+// To get the constructorName, run "console.log(object.constructor.name)" in the test.+// eslint-disable-next-line @typescript-eslint/no-unused-vars+async function findRetainerPaths(constructorName: string, maxPaths = 10): Promise<void> {+ const session: import('inspector').Session = new (require('node:inspector').Session)();+ session.connect();+ const chunks: string[] = [];+ session.on('HeapProfiler.addHeapSnapshotChunk', (m: any) => chunks.push(m.params.chunk));+ try {+ await new Promise<void>(f => session.post('HeapProfiler.takeHeapSnapshot', { reportProgress: false }, () => f()));+ } finally {+ session.disconnect();+ }+ const snapshot = JSON.parse(chunks.join(''));+ const { nodes, edges, strings, snapshot: meta } = snapshot;+ const nodeFields: string[] = meta.meta.node_fields;+ const edgeFields: string[] = meta.meta.edge_fields;+ const edgeTypes: string[] = meta.meta.edge_types[0];+ const nf = nodeFields.length;+ const ef = edgeFields.length;+ const nodeTypeOff = nodeFields.indexOf('type');+ const nodeNameOff = nodeFields.indexOf('name');+ const nodeIdOff = nodeFields.indexOf('id');+ const nodeEdgeCountOff = nodeFields.indexOf('edge_count');+ const edgeTypeOff = edgeFields.indexOf('type');+ const edgeNameOff = edgeFields.indexOf('name_or_index');+ const edgeToOff = edgeFields.indexOf('to_node');+ const nodeCount = nodes.length / nf;++ // Compute the first-edge index for every node (edges are laid out in node order).+ const firstEdge = new Uint32Array(nodeCount);+ let edgeCursor = 0;+ for (let i = 0; i < nodeCount; ++i) {+ firstEdge[i] = edgeCursor;+ edgeCursor += nodes[i * nf + nodeEdgeCountOff];+ }++ const nodeName = (i: number) => strings[nodes[i * nf + nodeNameOff]];+ const nodeTypeName = (i: number) => meta.meta.node_types[0][nodes[i * nf + nodeTypeOff]];++ // BFS from the synthetic root (node 0), recording how we reached each node.+ const parent = new Int32Array(nodeCount).fill(-1);+ const parentEdgeName = new Array<string>(nodeCount);+ const visited = new Uint8Array(nodeCount);+ visited[0] = 1;+ const queue = [0];+ for (let q = 0; q < queue.length; ++q) {+ const from = queue[q];+ const edgeStart = firstEdge[from];+ const count = nodes[from * nf + nodeEdgeCountOff];+ for (let e = 0; e < count; ++e) {+ const base = (edgeStart + e) * ef;+ const type = edgeTypes[edges[base + edgeTypeOff]];+ if (type === 'weak')+ continue; // Weak references do not retain.+ const to = edges[base + edgeToOff] / nf;+ if (visited[to])+ continue;+ visited[to] = 1;+ parent[to] = from;+ const rawName = edges[base + edgeNameOff];+ parentEdgeName[to] = (type === 'element' || type === 'hidden') ? `[${rawName}]` : strings[rawName];+ queue.push(to);+ }+ }++ const targets: number[] = [];+ for (let i = 0; i < nodeCount && targets.length < maxPaths; ++i) {+ if (nodeTypeName(i) === 'object' && nodeName(i) === constructorName)+ targets.push(i);+ }+ console.log(`\n===== retainer paths for ${constructorName} (showing ${targets.length}) =====`);+ for (const target of targets) {+ const path: string[] = [];+ let cur = target;+ while (cur !== -1) {+ const label = `${nodeName(cur)} (${nodeTypeName(cur)} @${nodes[cur * nf + nodeIdOff]})`;+ path.push(parent[cur] === -1 ? label : `${label} <--[${parentEdgeName[cur]}]--`);+ cur = parent[cur];+ }+ console.log(' ' + path.join('\n '));+ console.log(' ----');+ }+}+const clientClass = {Page: null as Function,BrowserContext: null as Function,@@ -135,6 +220,22 @@ test('should not leak dispatchers after closing page', async ({ context, serverexpect(await queryObjectCount(clientClass.Response)).toBe(0);});+test('should not leak workers', async ({ page }) => {+ const before = await queryObjectCount(coreServer.Worker);+ for (let i = 0; i < 5; ++i) {+ const [workerHandle, workerObj] = await Promise.all([+ page.evaluateHandle(index => new Worker(URL.createObjectURL(new Blob([String(index)], { type: 'application/javascript' }))), i),+ page.waitForEvent('worker'),+ ]);+ await Promise.all([+ workerObj.waitForEvent('close'),+ workerHandle.evaluate(workerObj => workerObj.terminate()),+ ]);+ }+ expect.soft(await queryObjectCount(coreServer.Worker)).toBe(before);+ expect.soft(await queryObjectCount(coreServer.WorkerDispatcher)).toBe(0);+});+test.describe(() => {test.beforeEach(() => {coreServer.setMaxDispatchersForTest(100);