fix(debug): do not generate source urls for anonymous scripts

src/client/frame.ts

@@ -410,6 +410,11 @@ export class Frame extends ChannelOwner<channels.FrameChannel, channels.FrameIni
       return (await this._channel.title()).value;
     });
   }
+
+  async _extendInjectedScript<Arg>(source: string, arg?: Arg): Promise<JSHandle> {
+    const result = await this._channel.extendInjectedScript({ source, arg: serializeArgument(arg) });
+    return JSHandle.from(result.handle);
+  }
 }
 
 export function verifyLoadState(name: string, waitUntil: LifecycleEvent): LifecycleEvent {

src/debug/debugController.ts

@@ -22,16 +22,10 @@ import { Progress } from '../server/progress';
 import { isDebugMode } from '../utils/utils';
 import * as debugScriptSource from '../generated/debugScriptSource';
 
-const debugScriptSymbol = Symbol('debugScript');
-
 export class DebugController implements InstrumentingAgent {
   private async ensureInstalledInFrame(frame: frames.Frame) {
     try {
-      const mainContext = await frame._mainContext();
-      if ((mainContext as any)[debugScriptSymbol])
-        return;
-      (mainContext as any)[debugScriptSymbol] = true;
-      await mainContext.extendInjectedScript(debugScriptSource.source);
+      await frame.extendInjectedScript(debugScriptSource.source);
     } catch (e) {
     }
   }

src/debug/injected/debugScript.ts

@@ -20,6 +20,8 @@ import type InjectedScript from '../../server/injected/injectedScript';
 export default class DebugScript {
   consoleAPI: ConsoleAPI | undefined;
   constructor(injectedScript: InjectedScript) {
+    if ((window as any).playwright)
+      return;
     this.consoleAPI = new ConsoleAPI(injectedScript);
   }
 }

src/dispatchers/frameDispatcher.ts

@@ -178,4 +178,8 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameInitializer
   async title(): Promise<channels.FrameTitleResult> {
     return { value: await this._frame.title() };
   }
+
+  async extendInjectedScript(params: channels.FrameExtendInjectedScriptParams): Promise<channels.FrameExtendInjectedScriptResult> {
+    return { handle: createHandle(this._scope, await this._frame.extendInjectedScript(params.source, parseArgument(params.arg))) };
+  }
 }

src/protocol/channels.ts

@@ -1111,6 +1111,7 @@ export interface FrameChannel extends Channel {
   uncheck(params: FrameUncheckParams): Promise<FrameUncheckResult>;
   waitForFunction(params: FrameWaitForFunctionParams): Promise<FrameWaitForFunctionResult>;
   waitForSelector(params: FrameWaitForSelectorParams): Promise<FrameWaitForSelectorResult>;
+  extendInjectedScript(params: FrameExtendInjectedScriptParams): Promise<FrameExtendInjectedScriptResult>;
 }
 export type FrameLoadstateEvent = {
   add?: 'load' | 'domcontentloaded' | 'networkidle',
@@ -1510,6 +1511,16 @@ export type FrameWaitForSelectorOptions = {
 export type FrameWaitForSelectorResult = {
   element?: ElementHandleChannel,
 };
+export type FrameExtendInjectedScriptParams = {
+  source: string,
+  arg: SerializedArgument,
+};
+export type FrameExtendInjectedScriptOptions = {
+
+};
+export type FrameExtendInjectedScriptResult = {
+  handle: JSHandleChannel,
+};
 
 // ----------- Worker -----------
 export type WorkerInitializer = {

src/protocol/protocol.yml

@@ -1242,6 +1242,14 @@ Frame:
       returns:
         element: ElementHandle?
 
+    extendInjectedScript:
+      experimental: True
+      parameters:
+        source: string
+        arg: SerializedArgument
+      returns:
+        handle: JSHandle
+
   events:
 
     loadstate:

src/protocol/validator.ts

@@ -604,6 +604,10 @@ export function createScheme(tChannel: (name: string) => Validator): Scheme {
     timeout: tOptional(tNumber),
     state: tOptional(tEnum(['attached', 'detached', 'visible', 'hidden'])),
   });
+  scheme.FrameExtendInjectedScriptParams = tObject({
+    source: tString,
+    arg: tType('SerializedArgument'),
+  });
   scheme.WorkerEvaluateExpressionParams = tObject({
     expression: tString,
     isFunction: tBoolean,

src/server/dom.ts

@@ -90,13 +90,6 @@ export class FrameExecutionContext extends js.ExecutionContext {
     return this._injectedScriptPromise;
   }
 
-  async extendInjectedScript(source: string, params?: any) {
-    const injectedScriptHandle = await this.injectedScript();
-    return injectedScriptHandle.evaluate((injectedScript, {source, params}) => {
-      return injectedScript.extend(source, params);
-    }, { source, params });
-  }
-
   async doSlowMo() {
     return this.frame._page._doSlowMo();
   }

src/server/frames.ts

@@ -975,6 +975,14 @@ export class Frame extends EventEmitter {
       clearTimeout(this._networkIdleTimer);
     this._networkIdleTimer = undefined;
   }
+
+  async extendInjectedScript(source: string, arg?: any): Promise<js.JSHandle> {
+    const mainContext = await this._mainContext();
+    const injectedScriptHandle = await mainContext.injectedScript();
+    return injectedScriptHandle.evaluateHandle((injectedScript, {source, arg}) => {
+      return injectedScript.extend(source, arg);
+    }, { source, arg });
+  }
 }
 
 class RerunnableTask {