From d1213e5a2279016b3429f933b39cc0979f6266d1 Mon Sep 17 00:00:00 2001
From: Lusa Zhan <[email protected]>
Date: Thu, 09 Jul 2026 15:02:39 +0000
Subject: [PATCH] [lighthouse] Scope ProtocolService proxy to the run's sessions

ProtocolService observes the front-end's shared CDPConnection and
previously forwarded every event with a sessionId into the Lighthouse
worker, and relayed every worker command back onto the connection
regardless of which session it addressed.

Track the parallel session created in attach() plus any child sessions
introduced via Target.attachedToTarget / Target.attachToTarget on
already-known sessions, and restrict both directions of the proxy to
that set. Worker commands that target an unknown session (including the
root session) are answered with a SESSION_NOT_FOUND error instead of
being sent.

This also stops events from unrelated DevTools sessions being broadcast
into the worker, which the worker discarded anyway.

Bug: 513850062
Change-Id: I69393978006683361ba356667d7392b54b437418
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/8070877
Reviewed-by: Danil Somsikov <[email protected]>
Commit-Queue: Lusa Zhan <[email protected]>
Reviewed-by: Simon Zünd <[email protected]>
---
diff --git a/front_end/panels/lighthouse/LighthouseProtocolService.test.ts b/front_end/panels/lighthouse/LighthouseProtocolService.test.ts
index a0a216d..92e88f6 100644
--- a/front_end/panels/lighthouse/LighthouseProtocolService.test.ts
+++ b/front_end/panels/lighthouse/LighthouseProtocolService.test.ts
@@ -6,6 +6,7 @@
 import sinon from 'sinon';
 
 import * as Platform from '../../core/platform/platform.js';
+import type * as ProtocolClient from '../../core/protocol_client/protocol_client.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 import {createTarget, describeWithEnvironment} from '../../testing/EnvironmentHelpers.js';
@@ -147,4 +148,125 @@
 
     sinon.assert.notCalled(handleDialogStub);
   });
+
+  describe('worker protocol proxying', () => {
+    const MAIN_SESSION_ID = 'LH_MAIN_SESSION' as Protocol.Target.SessionID;
+    const CHILD_SESSION_ID = 'LH_CHILD_SESSION' as Protocol.Target.SessionID;
+    const OTHER_SESSION_ID = 'OTHER_SESSION' as Protocol.Target.SessionID;
+
+    let connection: MockCDPConnection;
+    let connectionSend: sinon.SinonStub;
+    let workerPostMessage: sinon.SinonStub;
+    let mockWorker: Worker;
+    let workerStub: sinon.SinonStub;
+    let service: LighthouseModule.LighthouseProtocolService.ProtocolService;
+
+    function workerSend(payload: {id: number, method: string, params?: object, sessionId?: string}): void {
+      mockWorker.dispatchEvent(new MessageEvent('message', {
+        data: {action: 'sendProtocolMessage', args: {message: JSON.stringify(payload)}},
+      }));
+    }
+
+    function attachedToTargetEvent(outerSessionId: string, innerSessionId: string):
+        ProtocolClient.CDPConnection.CDPEvent<'Target.attachedToTarget'> {
+      return {
+        method: 'Target.attachedToTarget',
+        params: {
+          sessionId: innerSessionId as Protocol.Target.SessionID,
+          targetInfo: {
+            targetId: 'x' as Protocol.Target.TargetID,
+            type: 'page',
+            title: '',
+            url: 'http://example.com/',
+            attached: true,
+            canAccessOpener: false,
+          },
+          waitingForDebugger: true,
+        },
+        sessionId: outerSessionId,
+      };
+    }
+
+    beforeEach(async () => {
+      mockWorker = new EventTarget() as unknown as Worker;
+      workerPostMessage = sinon.stub();
+      mockWorker.postMessage = workerPostMessage as unknown as typeof mockWorker.postMessage;
+      mockWorker.terminate = sinon.stub() as unknown as typeof mockWorker.terminate;
+      workerStub = sinon.stub(globalThis, 'Worker').returns(mockWorker);
+
+      const router = rootTarget.router();
+      assert.exists(router);
+      connection = router.connection as MockCDPConnection;
+
+      connection.setSuccessHandler('Target.attachToTarget', () => ({sessionId: MAIN_SESSION_ID}));
+
+      service = new Lighthouse.LighthouseProtocolService.ProtocolService();
+      await service.attach(urlString`https://example.com/page`);
+
+      connectionSend = sinon.stub(connection, 'send').resolves({result: {}});
+
+      // Ensure the worker promise is resolved so that send() does not queue.
+      const workerReady = service.ensureWorkerExists();
+      mockWorker.dispatchEvent(new MessageEvent('message', {data: 'workerReady'}));
+      await workerReady;
+      workerPostMessage.resetHistory();
+    });
+
+    afterEach(() => {
+      workerStub.restore();
+    });
+
+    it('only relays worker commands targeting sessions created for the run', () => {
+      workerSend({id: 1, method: 'Runtime.enable', sessionId: MAIN_SESSION_ID});
+      sinon.assert.calledOnceWithExactly(connectionSend, 'Runtime.enable', undefined, MAIN_SESSION_ID);
+
+      connectionSend.resetHistory();
+      workerSend({id: 2, method: 'Target.setAutoAttach', params: {autoAttach: true}});
+      workerSend({id: 3, method: 'Target.setAutoAttach', params: {autoAttach: true}, sessionId: ''});
+      workerSend({id: 4, method: 'Runtime.enable', sessionId: OTHER_SESSION_ID});
+      sinon.assert.notCalled(connectionSend);
+    });
+
+    it('relays worker commands targeting auto-attached child sessions', () => {
+      service.onEvent(attachedToTargetEvent(MAIN_SESSION_ID, CHILD_SESSION_ID));
+
+      workerSend({id: 1, method: 'Runtime.enable', sessionId: CHILD_SESSION_ID});
+      sinon.assert.calledOnceWithExactly(connectionSend, 'Runtime.enable', undefined, CHILD_SESSION_ID);
+
+      connectionSend.resetHistory();
+      service.onEvent({
+        method: 'Target.detachedFromTarget',
+        params: {sessionId: CHILD_SESSION_ID, targetId: 'x' as Protocol.Target.TargetID},
+        sessionId: MAIN_SESSION_ID,
+      });
+      workerSend({id: 2, method: 'Runtime.enable', sessionId: CHILD_SESSION_ID});
+      sinon.assert.notCalled(connectionSend);
+    });
+
+    it('does not adopt empty child session ids from attachedToTarget', () => {
+      service.onEvent(attachedToTargetEvent(MAIN_SESSION_ID, ''));
+      workerSend({id: 1, method: 'Target.setAutoAttach', sessionId: ''});
+      workerSend({id: 2, method: 'Target.setAutoAttach'});
+      sinon.assert.notCalled(connectionSend);
+    });
+
+    it('only forwards events from sessions created for the run', async () => {
+      service.onEvent({method: 'Runtime.executionContextsCleared', params: undefined, sessionId: MAIN_SESSION_ID} as
+                      ProtocolClient.CDPConnection.CDPEvent<'Runtime.executionContextsCleared'>);
+      service.onEvent({method: 'Runtime.executionContextsCleared', params: undefined, sessionId: OTHER_SESSION_ID} as
+                      ProtocolClient.CDPConnection.CDPEvent<'Runtime.executionContextsCleared'>);
+      service.onEvent(attachedToTargetEvent(OTHER_SESSION_ID, CHILD_SESSION_ID));
+      await new Promise(resolve => setTimeout(resolve, 0));
+
+      const forwarded = workerPostMessage.getCalls()
+                            .map(call => call.args[0])
+                            .filter(message => message.action === 'dispatchProtocolMessage');
+      assert.lengthOf(forwarded, 1);
+      assert.strictEqual(forwarded[0].args.message.sessionId, MAIN_SESSION_ID);
+
+      // Child session ids introduced by events on unrelated sessions are not adopted.
+      workerSend({id: 1, method: 'Runtime.enable', sessionId: CHILD_SESSION_ID});
+      sinon.assert.notCalled(connectionSend);
+    });
+  });
 });
diff --git a/front_end/panels/lighthouse/LighthouseProtocolService.ts b/front_end/panels/lighthouse/LighthouseProtocolService.ts
index 795010c..5372d77 100644
--- a/front_end/panels/lighthouse/LighthouseProtocolService.ts
+++ b/front_end/panels/lighthouse/LighthouseProtocolService.ts
@@ -5,7 +5,7 @@
 import * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import type * as Platform from '../../core/platform/platform.js';
-import type * as ProtocolClient from '../../core/protocol_client/protocol_client.js';
+import * as ProtocolClient from '../../core/protocol_client/protocol_client.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 import type * as LighthouseModel from '../../models/lighthouse/lighthouse.js';
@@ -79,6 +79,14 @@
   private connection?: ProtocolClient.CDPConnection.CDPConnection;
 
   /**
+   * Session ids that belong to this Lighthouse run. The proxy only relays
+   * worker commands and connection events that target one of these sessions
+   * so that traffic stays scoped to the parallel session created in
+   * `attach()` and its descendants.
+   */
+  readonly #knownSessionIds = new Set<string>();
+
+  /**
    * Tracks pending requests to the Lighthouse worker.
    * Key: The message ID sent to the worker.
    * Value: The rejection function for the corresponding promise.
@@ -119,6 +127,8 @@
 
     const rootTargetId = await rootChildTargetManager.getParentTargetId();
     const {sessionId} = await rootTarget.targetAgent().invoke_attachToTarget({targetId: rootTargetId, flatten: true});
+    this.#knownSessionIds.clear();
+    this.#knownSessionIds.add(sessionId);
     this.connection = connection;
     this.connection.observe(this);
 
@@ -217,6 +227,7 @@
     this.rootTarget = undefined;
     this.connection?.unobserve(this);
     this.connection = undefined;
+    this.#knownSessionIds.clear();
 
     if (oldLighthouseWorker) {
       (await oldLighthouseWorker).terminate();
@@ -237,18 +248,29 @@
   }
 
   private dispatchProtocolMessage(message: ProtocolClient.CDPConnection.CDPReceivableMessage): void {
-    // A message without a sessionId is the main session of the main target (call it "Main session").
-    // A parallel connection and session was made that connects to the same main target (call it "Lighthouse session").
-    // Messages from the "Lighthouse session" have a sessionId.
-    // Without some care, there is a risk of sending the same events for the same main frame to Lighthouse–the backend
-    // will create events for the "Main session" and the "Lighthouse session".
-    // The workaround–only send message to Lighthouse if:
-    //   * the message has a sessionId (is not for the "Main session")
-    //   * the message does not have a sessionId (is for the "Main session"), but only for the Target domain
-    //     (to kickstart autoAttach in LH).
-    if (message.sessionId || ('method' in message && message.method?.startsWith('Target'))) {
-      void this.send('dispatchProtocolMessage', {message});
+    // The shared CDPConnection carries traffic for every DevTools session. A
+    // parallel session is created for the Lighthouse run in `attach()`, and the
+    // worker only ever needs traffic that belongs to that session or one of the
+    // child sessions it subsequently attaches. Filtering on `#knownSessionIds`
+    // keeps the proxy scoped to the run instead of broadcasting unrelated
+    // session traffic into the worker.
+    if (!message.sessionId || !this.#knownSessionIds.has(message.sessionId)) {
+      return;
     }
+    if ('method' in message) {
+      if (message.method === 'Target.attachedToTarget') {
+        const childSessionId = (message.params as Protocol.Target.AttachedToTargetEvent | undefined)?.sessionId;
+        if (childSessionId) {
+          this.#knownSessionIds.add(childSessionId);
+        }
+      } else if (message.method === 'Target.detachedFromTarget') {
+        const childSessionId = (message.params as Protocol.Target.DetachedFromTargetEvent | undefined)?.sessionId;
+        if (childSessionId) {
+          this.#knownSessionIds.delete(childSessionId);
+        }
+      }
+    }
+    void this.send('dispatchProtocolMessage', {message});
   }
 
   onDisconnect(): void {
@@ -303,11 +325,30 @@
 
   private sendProtocolMessage(message: string): void {
     const {id, method, params, sessionId} = JSON.parse(message);
+    // The worker is expected to only address the parallel session created in
+    // `attach()` or sessions discovered beneath it. Anything else, including
+    // the root session, is outside the scope of the run.
+    if (!sessionId || !this.#knownSessionIds.has(sessionId)) {
+      void this.send('dispatchProtocolMessage', {
+        message: {
+          id,
+          sessionId,
+          error: {
+            code: ProtocolClient.CDPConnection.CDPErrorStatus.SESSION_NOT_FOUND,
+            message: `Unknown session id: ${sessionId}`,
+          },
+        },
+      });
+      return;
+    }
     // CDPConnection manages it's own message IDs and it's important, otherwise we'd clash
     // with the rest of the DevTools traffic.
     // Instead, we ignore the ID coming from the worker when sending the command, but
     // patch it back in when sending the response back to the worker.
     void this.connection?.send(method, params, sessionId).then(response => {
+      if ('result' in response && method === 'Target.attachToTarget' && response.result?.sessionId) {
+        this.#knownSessionIds.add(response.result.sessionId);
+      }
       const message =
           'result' in response ? {id, sessionId, result: response.result} : {id, sessionId, error: response.error};
       this.dispatchProtocolMessage(message);