use the parent process descriptor instead of tab descriptors in Firefox 137

Author: hbenl

src/adapter/adapter/addonManager.ts

@@ -7,7 +7,6 @@ import { PreferenceActorProxy } from '../firefox/actorProxy/preference';
 import { FirefoxDebugSession } from '../firefoxDebugSession';
 import { PopupAutohideEventBody } from '../../common/customEvents';
 import { isWindowsPlatform } from '../../common/util';
-import { TargetActorProxy } from '../firefox/actorProxy/target';
 import { DescriptorActorProxy } from '../firefox/actorProxy/descriptor';
 
 const log = Log.create('AddonManager');
@@ -21,11 +20,12 @@ export const popupAutohidePreferenceKey = 'ui.popup.disable_autohide';
  */
 export class AddonManager {
 
+	private resolveAddonId!: (addonId: string) => void;
+	public readonly addonId = new Promise<string>(resolve => this.resolveAddonId = resolve);
+
 	private readonly config: ParsedAddonConfiguration;
 
-	private addonAttached = false;
 	private descriptorActor: DescriptorActorProxy | undefined = undefined;
-	private targetActor: TargetActorProxy | undefined = undefined;
 
 	constructor(
 		private readonly debugSession: FirefoxDebugSession
@@ -41,11 +41,9 @@ export class AddonManager {
 
 		const addonPath = isWindowsPlatform() ? path.normalize(this.config.path) : this.config.path;
 		let result = await addonsActor.installAddon(addonPath);
-		if (!this.config.id) {
-			this.config.id = result.addon.id;
-		}
+		this.resolveAddonId(result.addon.id);
 
-		this.fetchAddonsAndAttach(rootActor);
+		await this.fetchDescriptor(rootActor);
 
 		if (this.config.popupAutohideButton) {
 			const popupAutohide = !(await preferenceActor.getBoolPref(popupAutohidePreferenceKey));
@@ -54,34 +52,29 @@ export class AddonManager {
 	}
 
 	public async reloadAddon(): Promise<void> {
-		if (!this.targetActor) {
+		if (!this.descriptorActor) {
 			throw 'Addon isn\'t attached';
 		}
 
-		await this.descriptorActor?.reload();
+		await this.descriptorActor.reload();
 	}
 
-	private async fetchAddonsAndAttach(rootActor: RootActorProxy): Promise<void> {
-
-		if (this.addonAttached) return;
-
-		let addons = await rootActor.fetchAddons();
-
-		if (this.addonAttached) return;
-
-		addons.forEach((addon) => {
-			if (addon.id === this.config.id) {
-				(async () => {
+	private async fetchDescriptor(rootActor: RootActorProxy): Promise<void> {
 
-					this.descriptorActor = new DescriptorActorProxy(
-						addon.actor,
-						this.debugSession.firefoxDebugConnection
-					);
+		const addons = await rootActor.fetchAddons();
 
-					await this.debugSession.attachDescriptor(this.descriptorActor, false);
+		addons.forEach(async addon => {
+			if (addon.id === await this.addonId) {
+				this.descriptorActor = new DescriptorActorProxy(
+					addon.actor,
+					'webExtension',
+					this.debugSession.firefoxDebugConnection
+				);
 
-					this.addonAttached = true;
-				})();
+				if (!this.debugSession.processDescriptorMode) {
+					const adapter = await this.debugSession.attachDescriptor(this.descriptorActor);
+					await adapter.watcherActor.watchResources(['console-message', 'error-message', 'source', 'thread-state']);
+				}
 			}
 		});
 	}

src/adapter/adapter/descriptor.ts

@@ -17,7 +17,7 @@ export class DescriptorAdapter {
 		private readonly configurators: Registry<ThreadConfigurationActorProxy>,
 		private readonly breakpointLists: Registry<BreakpointListActorProxy>,
 		public readonly descriptorActor: DescriptorActorProxy,
-		private readonly watcherActor: WatcherActorProxy,
+		public readonly watcherActor: WatcherActorProxy,
 		private readonly configurator: ThreadConfigurationActorProxy,
 		private readonly breakpointList: BreakpointListActorProxy
 	) {

src/adapter/adapter/thread.ts

@@ -14,6 +14,8 @@ import { ISourceActorProxy } from '../firefox/actorProxy/source';
 
 let log = Log.create('ThreadAdapter');
 
+export type TargetType = 'tab' | 'iframe' | 'worker' | 'backgroundScript' | 'contentScript';
+
 /**
  * Adapter class for a thread
  */
@@ -23,6 +25,9 @@ export class ThreadAdapter extends EventEmitter {
 	public get actorName() {
 		return this.actor.name;
 	}
+	public get url(): string | undefined {
+		return this.targetActor.target.url;
+	}
 
 	/**
 	 * All `SourceAdapter`s for this thread. They will be disposed when this `ThreadAdapter` is disposed.
@@ -54,11 +59,11 @@ export class ThreadAdapter extends EventEmitter {
 	public threadPausedReason?: FirefoxDebugProtocol.ThreadPausedReason;
 
 	public constructor(
+		public readonly type: TargetType,
+		public readonly name: string,
 		public readonly actor: IThreadActorProxy,
 		public readonly targetActor: TargetActorProxy,
 		private readonly consoleActor: ConsoleActorProxy,
-		public readonly name: string,
-		public readonly url: string | undefined,
 		public readonly debugSession: FirefoxDebugSession
 	) {
 		super();

src/adapter/firefox/actorProxy/descriptor.ts

@@ -5,19 +5,29 @@ import { WatcherActorProxy } from './watcher';
 
 let log = Log.create('DescriptorActorProxy');
 
+export type DescriptorType = 'tab' | 'webExtension' | 'process';
+
 /**
  * Proxy class for a TabDescriptor or WebExtensionDescriptor actor
  */
 export class DescriptorActorProxy extends BaseActorProxy {
 
-	constructor(name: string, connection: DebugConnection) {
+	constructor(
+		name: string,
+		public readonly type: DescriptorType,
+		connection: DebugConnection
+	) {
 		super(name, connection, log);
 	}
 
 	public async getWatcher(): Promise<WatcherActorProxy> {
 		return await this.sendCachedRequest(
 			'getWatcher',
-			{ type: 'getWatcher', isServerTargetSwitchingEnabled: true, isPopupDebuggingEnabled: false },
+				{ type: 'getWatcher',
+					enableWindowGlobalThreadActors: this.type === 'process' ? true : undefined,
+					isServerTargetSwitchingEnabled: this.type !== 'process' ? true : undefined,
+					isPopupDebuggingEnabled: this.type === 'tab' ? false : undefined,
+				},
 			(response: FirefoxDebugProtocol.GetWatcherResponse) =>
 				new WatcherActorProxy(response.actor, !!response.traits.content_script, this.connection)
 		);

src/adapter/firefox/actorProxy/root.ts

@@ -58,6 +58,15 @@ export class RootActorProxy extends BaseActorProxy {
 		};
 	}
 
+	public async getProcess(id: number): Promise<DescriptorActorProxy> {
+		return this.sendCachedRequest(
+			`getProcess(${id})`,
+			{ type: 'getProcess', id },
+			(response: FirefoxDebugProtocol.GetProcessResponse) =>
+				new DescriptorActorProxy(response.processDescriptor.actor, 'process', this.connection)
+		)
+	}
+
 	public async fetchTabs(): Promise<Map<string, DescriptorActorProxy>> {
 		let tabsResponse: FirefoxDebugProtocol.TabsResponse = await this.sendRequest({ type: 'listTabs' });
 		while (tabsResponse.tabs.length === 0) {
@@ -80,7 +89,7 @@ export class RootActorProxy extends BaseActorProxy {
 
 				log.debug(`Tab ${tab.actor} opened`);
 
-				tabDescriptorActor = new DescriptorActorProxy(tab.actor, this.connection);
+				tabDescriptorActor = new DescriptorActorProxy(tab.actor, 'tab', this.connection);
 
 				this.emit('tabOpened', tabDescriptorActor);
 			}

src/adapter/firefox/actorProxy/target.ts

@@ -16,6 +16,10 @@ export class TargetActorProxy extends BaseActorProxy {
 		super(target.actor, connection, log);
 	}
 
+	public reload() {
+		return this.sendRequest({ type: 'reload' });
+	}
+
 	public onConsoleMessages(cb: (consoleMessages: FirefoxDebugProtocol.ConsoleMessage[]) => void) {
 		this.on('console-message', cb);
 	}

src/adapter/firefox/actorProxy/watcher.ts

@@ -47,7 +47,7 @@ export class WatcherActorProxy extends BaseActorProxy {
 		await this.sendRequest({ type: 'watchTargets', targetType });
 	}
 
-	public onTargetAvailable(cb: (target: [TargetActorProxy, IThreadActorProxy, ConsoleActorProxy, string | undefined]) => void) {
+	public onTargetAvailable(cb: (target: [TargetActorProxy, IThreadActorProxy, ConsoleActorProxy]) => void) {
 		this.on('targetAvailable', cb);
 	}
 
@@ -61,7 +61,7 @@ export class WatcherActorProxy extends BaseActorProxy {
 			const threadActorProxy = new ThreadActorProxy(event.target.threadActor, this.connection);
 			const sourcemappingThreadActorProxy = new SourceMappingThreadActorProxy(threadActorProxy, this.connection);
 			const consoleActorProxy = new ConsoleActorProxy(event.target.consoleActor, this.connection);
-			this.emit('targetAvailable', [targetActorProxy, sourcemappingThreadActorProxy, consoleActorProxy, event.target.url]);
+			this.emit('targetAvailable', [targetActorProxy, sourcemappingThreadActorProxy, consoleActorProxy]);
 		} else if (event.type === 'target-destroyed-form') {
 			this.emit('targetDestroyed', event.target.actor);
 		} else {

src/adapter/firefox/protocol.d.ts

@@ -35,6 +35,7 @@ declare namespace FirefoxDebugProtocol {
 			watchpoints?: boolean,
 			webExtensionAddonConnect?: boolean,
 			noPauseOnThreadActorAttach?: boolean
+			supportsEnableWindowGlobalThreadActors?: boolean
 		};
 	}
 
@@ -44,6 +45,21 @@ declare namespace FirefoxDebugProtocol {
 		deviceActor: string;
 	}
 
+	interface GetProcessResponse {
+		processDescriptor: ProcessDescriptor;
+	}
+
+	interface ProcessDescriptor {
+		actor: string;
+		id: number;
+		isParent: boolean;
+		isWindowlessParent: boolean;
+		traits: {
+			watcher: boolean;
+			supportsReloadDescriptor: boolean;
+		}
+	}
+
 	interface TabsResponse extends Response {
 		tabs: (Tab | TabDescriptor)[];
 	}
@@ -354,13 +370,24 @@ declare namespace FirefoxDebugProtocol {
 	}
 
 	interface TargetAvailableEvent extends Event {
+		type: 'target-available-form';
 		target: {
 			url?: string;
 			actor: string;
 			consoleActor: string;
 			threadActor: string;
+			targetType?: 'process' | 'frame' | 'worker' | 'shared_worker' | 'service_worker' | 'content_script';
 			isTopLevelTarget?: boolean;
 			isFallbackExtensionDocument?: boolean;
+			// set for all frame targets
+			innerWindowId?: number;
+			// set for iframe targets
+			parentInnerWindowId?: number;
+			// set for all frame targets
+			topInnerWindowId?: number;
+			// set for worker targets
+			relatedDocumentInnerWindowId?: number;
+			addonId?: string;
 		};
 	}
 

src/adapter/firefoxDebugAdapter.ts

@@ -224,7 +224,7 @@ export class FirefoxDebugAdapter extends DebugAdapterBase {
 		log.debug(`${this.session.threads.count} threads`);
 
 		let threads = this.session.threads.map(
-			(threadAdapter) => new Thread(threadAdapter.id, `${threadAdapter.name}: ${threadAdapter.url}`));
+			(threadAdapter) => new Thread(threadAdapter.id, threadAdapter.name));
 
 		return { threads };
 	}