Move onMissingCsp onto base

src/vs/workbench/contrib/webview/browser/baseWebviewElement.ts

@@ -4,8 +4,12 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { addClass } from 'vs/base/browser/dom';
+import { Emitter } from 'vs/base/common/event';
 import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
-import { WebviewOptions } from 'vs/workbench/contrib/webview/browser/webview';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { WebviewExtensionDescription, WebviewOptions } from 'vs/workbench/contrib/webview/browser/webview';
 
 export const enum WebviewMessageChannels {
 	onmessage = 'onmessage',
@@ -27,7 +31,13 @@ export abstract class BaseWebview<T extends HTMLElement> extends Disposable {
 
 	private readonly _ready: Promise<void>;
 
-	constructor(options: WebviewOptions) {
+	public extension: WebviewExtensionDescription | undefined;
+
+	constructor(
+		options: WebviewOptions,
+		@ITelemetryService private readonly _telemetryService: ITelemetryService,
+		@IEnvironmentService private readonly _environementService: IEnvironmentService,
+	) {
 		super();
 
 		this._element = this.createElement(options);
@@ -41,12 +51,11 @@ export abstract class BaseWebview<T extends HTMLElement> extends Disposable {
 				resolve();
 			}));
 		});
-	}
 
-	protected abstract createElement(options: WebviewOptions): T;
-
-	protected abstract on<T = unknown>(channel: WebviewMessageChannels, handler: (data: T) => void): IDisposable;
-	protected abstract postMessage(channel: string, data?: any): void;
+		this._register(this.on('no-csp-found', () => {
+			this.handleNoCspFound();
+		}));
+	}
 
 	dispose(): void {
 		if (this.element) {
@@ -57,9 +66,43 @@ export abstract class BaseWebview<T extends HTMLElement> extends Disposable {
 		super.dispose();
 	}
 
+	private readonly _onMissingCsp = this._register(new Emitter<ExtensionIdentifier>());
+	public readonly onMissingCsp = this._onMissingCsp.event;
+
 	protected _send(channel: string, data?: any): void {
 		this._ready
 			.then(() => this.postMessage(channel, data))
 			.catch(err => console.error(err));
 	}
+
+	protected abstract createElement(options: WebviewOptions): T;
+
+	protected abstract on<T = unknown>(channel: string, handler: (data: T) => void): IDisposable;
+
+	protected abstract postMessage(channel: string, data?: any): void;
+
+	private _hasAlertedAboutMissingCsp = false;
+	private handleNoCspFound(): void {
+		if (this._hasAlertedAboutMissingCsp) {
+			return;
+		}
+		this._hasAlertedAboutMissingCsp = true;
+
+		if (this.extension && this.extension.id) {
+			if (this._environementService.isExtensionDevelopment) {
+				this._onMissingCsp.fire(this.extension.id);
+			}
+
+			type TelemetryClassification = {
+				extension?: { classification: 'SystemMetaData', purpose: 'FeatureInsight'; };
+			};
+			type TelemetryData = {
+				extension?: string,
+			};
+
+			this._telemetryService.publicLog2<TelemetryData, TelemetryClassification>('webviewMissingCsp', {
+				extension: this.extension.id.value
+			});
+		}
+	}
 }

src/vs/workbench/contrib/webview/browser/webviewElement.ts

@@ -9,16 +9,17 @@ import { IDisposable } from 'vs/base/common/lifecycle';
 import { isWeb } from 'vs/base/common/platform';
 import { URI } from 'vs/base/common/uri';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { IFileService } from 'vs/platform/files/common/files';
 import { ITunnelService } from 'vs/platform/remote/common/tunnel';
-import { Webview, WebviewContentOptions, WebviewOptions, WebviewExtensionDescription } from 'vs/workbench/contrib/webview/browser/webview';
+import { Webview, WebviewContentOptions, WebviewOptions } from 'vs/workbench/contrib/webview/browser/webview';
 import { areWebviewInputOptionsEqual } from 'vs/workbench/contrib/webview/browser/webviewWorkbenchService';
 import { WebviewPortMappingManager } from 'vs/workbench/contrib/webview/common/portMapping';
 import { loadLocalResource } from 'vs/workbench/contrib/webview/common/resourceLoader';
 import { WebviewThemeDataProvider } from 'vs/workbench/contrib/webview/common/themeing';
 import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 import { BaseWebview, WebviewMessageChannels } from 'vs/workbench/contrib/webview/browser/baseWebviewElement';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 
 interface WebviewContent {
 	readonly html: string;
@@ -32,8 +33,6 @@ export class IFrameWebview extends BaseWebview<HTMLIFrameElement> implements Web
 
 	private readonly _portMappingManager: WebviewPortMappingManager;
 
-	public extension: WebviewExtensionDescription | undefined;
-
 	constructor(
 		private readonly id: string,
 		options: WebviewOptions,
@@ -43,8 +42,10 @@ export class IFrameWebview extends BaseWebview<HTMLIFrameElement> implements Web
 		@IWorkbenchEnvironmentService private readonly environmentService: IWorkbenchEnvironmentService,
 		@IFileService private readonly fileService: IFileService,
 		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@ITelemetryService telemetryService: ITelemetryService,
+		@IEnvironmentService environementService: IEnvironmentService,
 	) {
-		super(options);
+		super(options, telemetryService, environementService);
 		if (!this.useExternalEndpoint && (!environmentService.options || typeof environmentService.webviewExternalEndpoint !== 'string')) {
 			throw new Error('To use iframe based webviews, you must configure `environmentService.webviewExternalEndpoint`');
 		}
@@ -197,10 +198,6 @@ export class IFrameWebview extends BaseWebview<HTMLIFrameElement> implements Web
 	private readonly _onMessage = this._register(new Emitter<any>());
 	public readonly onMessage = this._onMessage.event;
 
-	private readonly _onMissingCsp = this._register(new Emitter<ExtensionIdentifier>());
-	public readonly onMissingCsp = this._onMissingCsp.event;
-
-
 	sendMessage(data: any): void {
 		this._send('message', data);
 	}

src/vs/workbench/contrib/webview/electron-browser/webviewElement.ts

@@ -12,7 +12,6 @@ import { isMacintosh } from 'vs/base/common/platform';
 import { URI } from 'vs/base/common/uri';
 import * as modes from 'vs/editor/common/modes';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
-import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
 import { IFileService } from 'vs/platform/files/common/files';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ITunnelService } from 'vs/platform/remote/common/tunnel';
@@ -253,10 +252,10 @@ export class ElectronWebviewBasedWebview extends BaseWebview<WebviewTag> impleme
 		@IInstantiationService instantiationService: IInstantiationService,
 		@IFileService fileService: IFileService,
 		@ITunnelService tunnelService: ITunnelService,
-		@ITelemetryService private readonly _telemetryService: ITelemetryService,
-		@IEnvironmentService private readonly _environementService: IEnvironmentService,
+		@ITelemetryService telemetryService: ITelemetryService,
+		@IEnvironmentService environementService: IEnvironmentService,
 	) {
-		super(options);
+		super(options, telemetryService, environementService);
 
 		this.content = {
 			html: '',
@@ -351,10 +350,6 @@ export class ElectronWebviewBasedWebview extends BaseWebview<WebviewTag> impleme
 			this.handleFocusChange(false);
 		}));
 
-		this._register(this.on('no-csp-found', () => {
-			this.handleNoCspFound();
-		}));
-
 		this._register(addDisposableListener(this.element!, 'devtools-opened', () => {
 			this._send('devtools-opened');
 		}));
@@ -411,9 +406,6 @@ export class ElectronWebviewBasedWebview extends BaseWebview<WebviewTag> impleme
 	private readonly _onMessage = this._register(new Emitter<any>());
 	public readonly onMessage = this._onMessage.event;
 
-	private readonly _onMissingCsp = this._register(new Emitter<ExtensionIdentifier>());
-	public readonly onMissingCsp = this._onMissingCsp.event;
-
 	protected postMessage(channel: string, data?: any): void {
 		if (this.element) {
 			this.element.send(channel, data);
@@ -484,32 +476,6 @@ export class ElectronWebviewBasedWebview extends BaseWebview<WebviewTag> impleme
 		}
 	}
 
-	private _hasAlertedAboutMissingCsp = false;
-
-	private handleNoCspFound(): void {
-		if (this._hasAlertedAboutMissingCsp) {
-			return;
-		}
-		this._hasAlertedAboutMissingCsp = true;
-
-		if (this.extension && this.extension.id) {
-			if (this._environementService.isExtensionDevelopment) {
-				this._onMissingCsp.fire(this.extension.id);
-			}
-
-			type TelemetryClassification = {
-				extension?: { classification: 'SystemMetaData', purpose: 'FeatureInsight'; };
-			};
-			type TelemetryData = {
-				extension?: string,
-			};
-
-			this._telemetryService.publicLog2<TelemetryData, TelemetryClassification>('webviewMissingCsp', {
-				extension: this.extension.id.value
-			});
-		}
-	}
-
 	public sendMessage(data: any): void {
 		this._send('message', data);
 	}