chrome-devtools-frontend 1.0.1539728 → 1.0.1539972

package/front_end/core/common/Debouncer.ts

@@ -6,10 +6,10 @@
  * Debounce utility function, ensures that the function passed in is only called once the function stops being called and the delay has expired.
  */
 export const debounce = function(func: (...args: any[]) => void, delay: number): (...args: any[]) => void {
-  let timer = 0;
+  let timer: ReturnType<typeof setTimeout>;
   const debounced = (...args: any[]): void => {
     clearTimeout(timer);
-    timer = window.setTimeout(() => func(...args), delay);
+    timer = setTimeout(() => func(...args), delay);
   };
   return debounced;
 };

package/front_end/core/common/Gzip.ts

@@ -54,7 +54,7 @@ async function gzipCodec(
     codecStream: CompressionStream|DecompressionStream): Promise<ArrayBuffer> {
   const readable = new ReadableStream({
     start(controller) {
-      controller.enqueue(buffer);
+      controller.enqueue(buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer);
       controller.close();
     }
   });

package/front_end/core/common/Throttler.ts

@@ -9,7 +9,7 @@ export class Throttler {
   #process: (() => (void|Promise<unknown>))|null;
   #lastCompleteTime: number;
   #scheduler = Promise.withResolvers<unknown>();
-  #processTimeout?: number;
+  #processTimeout?: ReturnType<typeof setTimeout>;
 
   constructor(timeout: number) {
     this.#timeout = timeout;
@@ -78,11 +78,11 @@ export class Throttler {
     clearTimeout(this.#processTimeout);
 
     const timeout = this.#asSoonAsPossible ? 0 : this.#timeout;
-    this.#processTimeout = window.setTimeout(this.#onTimeout.bind(this), timeout);
+    this.#processTimeout = setTimeout(this.#onTimeout.bind(this), timeout);
   }
 
   #getTime(): number {
-    return window.performance.now();
+    return performance.now();
   }
 }
 

package/front_end/core/host/GdpClient.ts

@@ -85,6 +85,7 @@ function normalizeBadgeName(name: string): string {
 }
 
 export const GOOGLE_DEVELOPER_PROGRAM_PROFILE_LINK = 'https://developers.google.com/profile/u/me';
+const ORIGIN_APPLICATION_NAME = 'APPLICATION_CHROME_DEVTOOLS';
 
 async function makeHttpRequest<R>(request: DispatchHttpRequestRequest): Promise<R> {
   if (!isGdpProfilesAvailable()) {
@@ -208,6 +209,9 @@ export class GdpClient {
         body: JSON.stringify({
           user,
           newsletter_email: emailPreference,
+          creation_origin: {
+            origin_application: ORIGIN_APPLICATION_NAME,
+          }
         }),
       });
       this.#clearCache();

package/front_end/core/protocol_client/DevToolsCDPConnection.ts

@@ -0,0 +1,181 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import {
+  type CDPCommandRequest,
+  type CDPConnection,
+  type CDPConnectionObserver,
+  type CDPError,
+  CDPErrorStatus,
+  type CDPReceivableMessage,
+  type Command,
+  type CommandParams,
+  type CommandResult
+} from './CDPConnection.js';
+import type {ConnectionTransport} from './ConnectionTransport.js';
+import {InspectorBackend, type MessageError, type QualifiedName, test} from './InspectorBackend.js';
+
+interface CallbackWithDebugInfo {
+  resolve: (response: Awaited<ReturnType<CDPConnection['send']>>) => void;
+  method: string;
+  sessionId: string|undefined;
+}
+
+type Callback = (error: MessageError|null, arg1: Object|null) => void;
+
+const LongPollingMethods = new Set<string>(['CSS.takeComputedStyleUpdates']);
+
+export class DevToolsCDPConnection implements CDPConnection {
+  readonly #transport: ConnectionTransport;
+  #lastMessageId = 1;
+  #pendingResponsesCount = 0;
+  readonly #pendingLongPollingMessageIds = new Set<number>();
+  #pendingScripts: Array<() => void> = [];
+  readonly #callbacks = new Map<number, CallbackWithDebugInfo>();
+  readonly #observers = new Set<CDPConnectionObserver>();
+
+  constructor(transport: ConnectionTransport) {
+    this.#transport = transport;
+
+    test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
+    test.sendRawMessage = this.sendRawMessageForTesting.bind(this);
+
+    this.#transport.setOnMessage(this.onMessage.bind(this));
+    this.#transport.setOnDisconnect(reason => {
+      this.#observers.forEach(observer => observer.onDisconnect(reason));
+    });
+  }
+
+  observe(observer: CDPConnectionObserver): void {
+    this.#observers.add(observer);
+  }
+
+  unobserve(observer: CDPConnectionObserver): void {
+    this.#observers.delete(observer);
+  }
+
+  send<T extends Command>(method: T, params: CommandParams<T>, sessionId: string|undefined):
+      Promise<{result: CommandResult<T>}|{error: CDPError}> {
+    const messageId = ++this.#lastMessageId;
+    const messageObject: Partial<CDPCommandRequest<T>> = {
+      id: messageId,
+      method,
+    };
+
+    if (params) {
+      messageObject.params = params;
+    }
+    if (sessionId) {
+      messageObject.sessionId = sessionId;
+    }
+
+    if (test.dumpProtocol) {
+      test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
+    }
+
+    if (test.onMessageSent) {
+      const domain = method.split('.')[0];
+      const paramsObject = JSON.parse(JSON.stringify(params || {}));
+      test.onMessageSent({domain, method, params: (paramsObject as Object), id: messageId, sessionId});
+    }
+
+    ++this.#pendingResponsesCount;
+    if (LongPollingMethods.has(method)) {
+      this.#pendingLongPollingMessageIds.add(messageId);
+    }
+
+    return new Promise(resolve => {
+      this.#callbacks.set(messageId, {resolve, method, sessionId});
+      this.#transport.sendRawMessage(JSON.stringify(messageObject));
+    });
+  }
+
+  resolvePendingCalls(sessionId: string): void {
+    for (const {resolve, method, sessionId: callbackSessionId} of this.#callbacks.values()) {
+      if (sessionId !== callbackSessionId) {
+        continue;
+      }
+      resolve({
+        error: {
+          message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
+          code: CDPErrorStatus.SESSION_NOT_FOUND,
+        }
+      });
+    }
+  }
+
+  private sendRawMessageForTesting(method: QualifiedName, params: Object|null, callback: Callback|null, sessionId = ''):
+      void {
+    void this.send(method as Command, params as CommandParams<Command>, sessionId).then(response => {
+      if ('error' in response && response.error) {
+        callback?.(response.error, null);
+      } else if ('result' in response) {
+        callback?.(null, response.result as Object | null);
+      }
+    });
+  }
+
+  private onMessage(message: string|Object): void {
+    if (test.dumpProtocol) {
+      test.dumpProtocol('backend: ' + ((typeof message === 'string') ? message : JSON.stringify(message)));
+    }
+
+    if (test.onMessageReceived) {
+      const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
+      test.onMessageReceived(messageObjectCopy);
+    }
+
+    const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message) as CDPReceivableMessage;
+
+    if ('id' in messageObject && messageObject.id !== undefined) {  // just a response for some request
+      const callback = this.#callbacks.get(messageObject.id);
+      this.#callbacks.delete(messageObject.id);
+      if (!callback) {
+        // Ignore messages with unknown IDs, we might see puppeteer proxied messages here.
+        return;
+      }
+
+      callback.resolve(messageObject);
+      --this.#pendingResponsesCount;
+      this.#pendingLongPollingMessageIds.delete(messageObject.id);
+
+      if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
+        this.deprecatedRunAfterPendingDispatches();
+      }
+    } else if ('method' in messageObject) {
+      this.#observers.forEach(observer => observer.onEvent(messageObject));
+    } else {
+      InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
+    }
+  }
+
+  private hasOutstandingNonLongPollingRequests(): boolean {
+    return this.#pendingResponsesCount - this.#pendingLongPollingMessageIds.size > 0;
+  }
+
+  private deprecatedRunAfterPendingDispatches(script?: (() => void)): void {
+    if (script) {
+      this.#pendingScripts.push(script);
+    }
+
+    // Execute all promises.
+    setTimeout(() => {
+      if (!this.hasOutstandingNonLongPollingRequests()) {
+        this.executeAfterPendingDispatches();
+      } else {
+        this.deprecatedRunAfterPendingDispatches();
+      }
+    }, 0);
+  }
+
+  private executeAfterPendingDispatches(): void {
+    if (!this.hasOutstandingNonLongPollingRequests()) {
+      const scripts = this.#pendingScripts;
+      this.#pendingScripts = [];
+      for (let id = 0; id < scripts.length; ++id) {
+        scripts[id]();
+      }
+    }
+  }
+}

package/front_end/core/protocol_client/InspectorBackend.ts

@@ -8,18 +8,16 @@ import type * as Protocol from '../../generated/protocol.js';
 import type * as Platform from '../platform/platform.js';
 
 import {
-  type CDPCommandRequest,
   type CDPConnection,
   type CDPConnectionObserver,
-  type CDPError,
   CDPErrorStatus,
-  type CDPReceivableMessage,
+  type CDPEvent,
   type Command,
   type CommandParams,
-  type CommandResult
+  type Event
 } from './CDPConnection.js';
 import {ConnectionTransport} from './ConnectionTransport.js';
-import {NodeURL} from './NodeURL.js';
+import {DevToolsCDPConnection} from './DevToolsCDPConnection.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type MessageParams = Record<string, any>;
@@ -66,14 +64,6 @@ type ReadonlyEventParameterNames = ReadonlyMap<QualifiedName, string[]>;
 
 type CommandParameter = InspectorBackendCommands.CommandParameter;
 
-type Callback = (error: MessageError|null, arg1: Object|null) => void;
-
-interface CallbackWithDebugInfo {
-  resolve: (response: Awaited<ReturnType<CDPConnection['send']>>) => void;
-  method: string;
-  sessionId: string|undefined;
-}
-
 export class InspectorBackend implements InspectorBackendCommands.InspectorBackendAPI {
   readonly agentPrototypes = new Map<ProtocolDomainName, AgentPrototype>();
   #eventParameterNamesForDomain = new Map<ProtocolDomainName, EventParameterNames>();
@@ -192,43 +182,15 @@ export const test = {
   onMessageReceived: null as ((message: Object) => void) | null,
 };
 
-const LongPollingMethods = new Set<string>(['CSS.takeComputedStyleUpdates']);
-
-export class SessionRouter implements CDPConnection {
-  readonly #connection: ConnectionTransport;
-  #lastMessageId = 1;
-  #pendingResponsesCount = 0;
-  readonly #pendingLongPollingMessageIds = new Set<number>();
+export class SessionRouter implements CDPConnectionObserver {
+  readonly #connection: CDPConnection;
   readonly #sessions = new Map<string, {
     target: TargetBase,
   }>();
-  #pendingScripts: Array<() => void> = [];
-  readonly #callbacks = new Map<number, CallbackWithDebugInfo>();
-  readonly #observers = new Set<CDPConnectionObserver>();
 
-  constructor(connection: ConnectionTransport) {
+  constructor(connection: CDPConnection) {
     this.#connection = connection;
-
-    test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
-    test.sendRawMessage = this.sendRawMessageForTesting.bind(this);
-
-    this.#connection.setOnMessage(this.onMessage.bind(this));
-
-    this.#connection.setOnDisconnect(reason => {
-      const session = this.#sessions.get('');
-      if (session) {
-        session.target.dispose(reason);
-      }
-      this.#observers.forEach(observer => observer.onDisconnect(reason));
-    });
-  }
-
-  observe(observer: CDPConnectionObserver): void {
-    this.#observers.add(observer);
-  }
-
-  unobserve(observer: CDPConnectionObserver): void {
-    this.#observers.delete(observer);
+    this.#connection.observe(this);
   }
 
   registerSession(target: TargetBase, sessionId: string): void {
@@ -240,145 +202,27 @@ export class SessionRouter implements CDPConnection {
     if (!session) {
       return;
     }
-    for (const {resolve, method, sessionId: callbackSessionId} of this.#callbacks.values()) {
-      if (sessionId !== callbackSessionId) {
-        continue;
-      }
-      resolve({
-        error: {
-          message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
-          code: CDPErrorStatus.SESSION_NOT_FOUND,
-        }
-      });
+    if (this.#connection instanceof DevToolsCDPConnection) {
+      this.#connection.resolvePendingCalls(sessionId);
     }
     this.#sessions.delete(sessionId);
   }
 
-  private nextMessageId(): number {
-    return this.#lastMessageId++;
-  }
-
-  connection(): ConnectionTransport {
-    return this.#connection;
-  }
-
-  send<T extends Command>(method: T, params: CommandParams<T>, sessionId: string|undefined):
-      Promise<{result: CommandResult<T>}|{error: CDPError}> {
-    const messageId = this.nextMessageId();
-    const messageObject: Partial<CDPCommandRequest<T>> = {
-      id: messageId,
-      method,
-    };
-
-    if (params) {
-      messageObject.params = params;
-    }
-    if (sessionId) {
-      messageObject.sessionId = sessionId;
-    }
-
-    if (test.dumpProtocol) {
-      test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
-    }
-
-    if (test.onMessageSent) {
-      const domain = method.split('.')[0];
-      const paramsObject = JSON.parse(JSON.stringify(params || {}));
-      test.onMessageSent({domain, method, params: (paramsObject as Object), id: messageId, sessionId});
+  onDisconnect(reason: string): void {
+    const session = this.#sessions.get('');
+    if (session) {
+      session.target.dispose(reason);
     }
-
-    ++this.#pendingResponsesCount;
-    if (LongPollingMethods.has(method)) {
-      this.#pendingLongPollingMessageIds.add(messageId);
-    }
-
-    return new Promise(resolve => {
-      this.#callbacks.set(messageId, {resolve, method, sessionId});
-      this.#connection.sendRawMessage(JSON.stringify(messageObject));
-    });
-  }
-
-  private sendRawMessageForTesting(method: QualifiedName, params: Object|null, callback: Callback|null, sessionId = ''):
-      void {
-    void this.send(method as Command, params as CommandParams<Command>, sessionId).then(response => {
-      if ('error' in response && response.error) {
-        callback?.(response.error, null);
-      } else if ('result' in response) {
-        callback?.(null, response.result as Object | null);
-      }
-    });
   }
 
-  private onMessage(message: string|Object): void {
-    if (test.dumpProtocol) {
-      test.dumpProtocol('backend: ' + ((typeof message === 'string') ? message : JSON.stringify(message)));
-    }
-
-    if (test.onMessageReceived) {
-      const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
-      test.onMessageReceived(messageObjectCopy);
-    }
-
-    const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message) as CDPReceivableMessage;
-
-    const sessionId = messageObject.sessionId || '';
+  onEvent<T extends Event>(event: CDPEvent<T>): void {
+    const sessionId = event.sessionId || '';
     const session = this.#sessions.get(sessionId);
-
-    if (session?.target.getNeedsNodeJSPatching()) {
-      NodeURL.patch(messageObject);
-    }
-
-    if ('id' in messageObject && messageObject.id !== undefined) {  // just a response for some request
-      const callback = this.#callbacks.get(messageObject.id);
-      this.#callbacks.delete(messageObject.id);
-      if (!callback) {
-        // Ignore messages with unknown IDs, we might see puppeteer proxied messages here.
-        return;
-      }
-
-      callback.resolve(messageObject);
-      --this.#pendingResponsesCount;
-      this.#pendingLongPollingMessageIds.delete(messageObject.id);
-
-      if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
-        this.deprecatedRunAfterPendingDispatches();
-      }
-    } else if ('method' in messageObject) {
-      // This cast is justified as we just checked for the presence of messageObject.method.
-      session?.target.dispatch(messageObject as unknown as EventMessage);
-      this.#observers.forEach(observer => observer.onEvent(messageObject));
-    } else {
-      InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
-    }
-  }
-
-  private hasOutstandingNonLongPollingRequests(): boolean {
-    return this.#pendingResponsesCount - this.#pendingLongPollingMessageIds.size > 0;
+    session?.target.dispatch(event as unknown as EventMessage);
   }
 
-  private deprecatedRunAfterPendingDispatches(script?: (() => void)): void {
-    if (script) {
-      this.#pendingScripts.push(script);
-    }
-
-    // Execute all promises.
-    window.setTimeout(() => {
-      if (!this.hasOutstandingNonLongPollingRequests()) {
-        this.executeAfterPendingDispatches();
-      } else {
-        this.deprecatedRunAfterPendingDispatches();
-      }
-    }, 0);
-  }
-
-  private executeAfterPendingDispatches(): void {
-    if (!this.hasOutstandingNonLongPollingRequests()) {
-      const scripts = this.#pendingScripts;
-      this.#pendingScripts = [];
-      for (let id = 0; id < scripts.length; ++id) {
-        scripts[id]();
-      }
-    }
+  get connection(): CDPConnection {
+    return this.#connection;
   }
 }
 
@@ -401,16 +245,12 @@ interface DispatcherMap extends Map<ProtocolDomainName, ProtocolProxyApi.Protoco
 }
 
 export class TargetBase {
-  needsNodeJSPatching: boolean;
   readonly sessionId: string;
   #router: SessionRouter|null;
   #agents: AgentsMap = new Map();
   #dispatchers: DispatcherMap = new Map();
 
-  constructor(
-      needsNodeJSPatching: boolean, parentTarget: TargetBase|null, sessionId: string,
-      connection: ConnectionTransport|null) {
-    this.needsNodeJSPatching = needsNodeJSPatching;
+  constructor(parentTarget: TargetBase|null, sessionId: string, connection: CDPConnection|null) {
     this.sessionId = sessionId;
 
     if (parentTarget && !sessionId) {
@@ -423,7 +263,7 @@ export class TargetBase {
     } else if (connection) {
       router = new SessionRouter(connection);
     } else {
-      router = new SessionRouter(ConnectionTransport.getFactory()());
+      router = new SessionRouter(new DevToolsCDPConnection(ConnectionTransport.getFactory()()));
     }
 
     this.#router = router;
@@ -465,10 +305,6 @@ export class TargetBase {
     return !this.#router;
   }
 
-  markAsNodeJSForTest(): void {
-    this.needsNodeJSPatching = true;
-  }
-
   router(): SessionRouter|null {
     return this.#router;
   }
@@ -798,10 +634,6 @@ export class TargetBase {
   registerWebAuthnDispatcher(dispatcher: ProtocolProxyApi.WebAuthnDispatcher): void {
     this.registerDispatcher('WebAuthn', dispatcher);
   }
-
-  getNeedsNodeJSPatching(): boolean {
-    return this.needsNodeJSPatching;
-  }
 }
 
 /** These are not logged as console.error */
@@ -844,25 +676,26 @@ class AgentPrototype {
   }
 
   private invoke(method: QualifiedName, request: Object|null): Promise<Protocol.ProtocolResponseWithError> {
-    const router = this.target.router();
-    if (!router) {
+    const connection = this.target.router()?.connection;
+    if (!connection) {
       return Promise.resolve(
           {result: null, getError: () => `Connection is closed, can\'t dispatch pending call to ${method}`});
     }
 
-    return router.send(method as Command, request as CommandParams<Command>, this.target.sessionId).then(response => {
-      if ('error' in response && response.error) {
-        if (!test.suppressRequestErrors && !IGNORED_ERRORS.has(response.error.code)) {
-          console.error('Request ' + method + ' failed. ' + JSON.stringify(response.error));
-        }
-        return {getError: () => response.error.message};
-      }
-
-      if ('result' in response) {
-        return {...response.result, getError: () => undefined};
-      }
-      return {getError: () => undefined};
-    });
+    return connection.send(method as Command, request as CommandParams<Command>, this.target.sessionId)
+        .then(response => {
+          if ('error' in response && response.error) {
+            if (!test.suppressRequestErrors && !IGNORED_ERRORS.has(response.error.code)) {
+              console.error('Request ' + method + ' failed. ' + JSON.stringify(response.error));
+            }
+            return {getError: () => response.error.message};
+          }
+
+          if ('result' in response) {
+            return {...response.result, getError: () => undefined};
+          }
+          return {getError: () => undefined};
+        });
   }
 }
 

package/front_end/core/protocol_client/protocol_client.ts

@@ -4,12 +4,12 @@
 
 import * as CDPConnection from './CDPConnection.js';
 import * as ConnectionTransport from './ConnectionTransport.js';
+import * as DevToolsCDPConnection from './DevToolsCDPConnection.js';
 import * as InspectorBackend from './InspectorBackend.js';
-import * as NodeURL from './NodeURL.js';
 
 export {
   CDPConnection,
   ConnectionTransport,
+  DevToolsCDPConnection,
   InspectorBackend,
-  NodeURL,
 };

package/front_end/core/sdk/DebuggerModel.ts

@@ -5,9 +5,8 @@
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
 import * as Common from '../common/common.js';
-import * as Host from '../host/host.js';
 import * as i18n from '../i18n/i18n.js';
-import * as Platform from '../platform/platform.js';
+import type * as Platform from '../platform/platform.js';
 import * as Root from '../root/root.js';
 
 import type {PageResourceLoadInitiator} from './PageResourceLoader.js';
@@ -18,7 +17,7 @@ import {Script} from './Script.js';
 import {SDKModel} from './SDKModel.js';
 import {SourceMap} from './SourceMap.js';
 import {SourceMapManager} from './SourceMapManager.js';
-import {Capability, type Target, Type} from './Target.js';
+import {Capability, type Target} from './Target.js';
 
 const UIStrings = {
   /**
@@ -456,17 +455,6 @@ export class DebuggerModel extends SDKModel<EventTypes> {
   async setBreakpointByURL(
       url: Platform.DevToolsPath.UrlString, lineNumber: number, columnNumber?: number,
       condition?: BackendCondition): Promise<SetBreakpointResult> {
-    // Convert file url to node-js path.
-    let urlRegex;
-    if (this.target().type() === Type.NODE && Common.ParsedURL.schemeIs(url, 'file:')) {
-      const platformPath = Common.ParsedURL.ParsedURL.urlToRawPathString(url, Host.Platform.isWin());
-      urlRegex =
-          `${Platform.StringUtilities.escapeForRegExp(platformPath)}|${Platform.StringUtilities.escapeForRegExp(url)}`;
-      if (Host.Platform.isWin() && platformPath.match(/^.:\\/)) {
-        // Match upper or lower case drive letter
-        urlRegex = `[${platformPath[0].toUpperCase()}${platformPath[0].toLowerCase()}]` + urlRegex.substr(1);
-      }
-    }
     // Adjust column if needed.
     let minColumnNumber = 0;
     const scripts = this.#scriptsBySourceURL.get(url) || [];
@@ -479,8 +467,7 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     columnNumber = Math.max(columnNumber || 0, minColumnNumber);
     const response = await this.agent.invoke_setBreakpointByUrl({
       lineNumber,
-      url: urlRegex ? undefined : url,
-      urlRegex,
+      url,
       columnNumber,
       condition,
     });

package/front_end/core/sdk/RemoteObject.ts

@@ -841,6 +841,10 @@ export class LocalJSONObject extends RemoteObject {
       return 'date';
     }
 
+    if (this.#value instanceof Error) {
+      return 'error';
+    }
+
     return undefined;
   }
 

package/front_end/core/sdk/Target.ts

@@ -39,10 +39,8 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
   constructor(
       targetManager: TargetManager, id: Protocol.Target.TargetID|'main', name: string, type: Type,
       parentTarget: Target|null, sessionId: string, suspended: boolean,
-      connection: ProtocolClient.ConnectionTransport.ConnectionTransport|null,
-      targetInfo?: Protocol.Target.TargetInfo) {
-    const needsNodeJSPatching = type === Type.NODE;
-    super(needsNodeJSPatching, parentTarget, sessionId, connection);
+      connection: ProtocolClient.CDPConnection.CDPConnection|null, targetInfo?: Protocol.Target.TargetInfo) {
+    super(parentTarget, sessionId, connection);
     this.#targetManager = targetManager;
     this.#name = name;
     this.#capabilitiesMask = 0;
@@ -151,8 +149,7 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
     return this.#type;
   }
 
-  override markAsNodeJSForTest(): void {
-    super.markAsNodeJSForTest();
+  markAsNodeJSForTest(): void {
     this.#type = Type.NODE;
   }