Vscode merge (#4582)

* Merge from vscode 37cb23d3dd4f9433d56d4ba5ea3203580719a0bd * fix issues with merges * bump node version in azpipe * replace license headers * remove duplicate launch task * fix build errors * fix build errors * fix tslint issues * working through package and linux build issues * more work * wip * fix packaged builds * working through linux build errors * wip * wip * wip * fix mac and linux file limits * iterate linux pipeline * disable editor typing * revert series to parallel * remove optimize vscode from linux * fix linting issues * revert testing change * add work round for new node * readd packaging for extensions * fix issue with angular not resolving decorator dependencies
2026-01-19 09:35:36 -05:00 · 2019-03-19 17:44:35 -07:00
parent 833d197412
commit 87765e8673
1879 changed files with 54505 additions and 38058 deletions
--- a/src/vs/workbench/api/electron-browser/mainThreadWebview.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadWebview.ts
@@ -2,84 +2,99 @@
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
-import { dispose, IDisposable } from 'vs/base/common/lifecycle';
+import { onUnexpectedError } from 'vs/base/common/errors';
+import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
 import * as map from 'vs/base/common/map';
 import { URI, UriComponents } from 'vs/base/common/uri';
+import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
 import { localize } from 'vs/nls';
+import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ILifecycleService } from 'vs/platform/lifecycle/common/lifecycle';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
-import { ExtHostContext, ExtHostWebviewsShape, IExtHostContext, MainContext, MainThreadWebviewsShape, WebviewPanelHandle, WebviewPanelShowOptions } from 'vs/workbench/api/node/extHost.protocol';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { ExtHostContext, ExtHostWebviewsShape, IExtHostContext, MainContext, MainThreadWebviewsShape, WebviewInsetHandle, WebviewPanelHandle, WebviewPanelShowOptions } from 'vs/workbench/api/node/extHost.protocol';
 import { editorGroupToViewColumn, EditorViewColumn, viewColumnToEditorGroup } from 'vs/workbench/api/shared/editor';
-import { WebviewEditor } from 'vs/workbench/parts/webview/electron-browser/webviewEditor';
-import { WebviewEditorInput } from 'vs/workbench/parts/webview/electron-browser/webviewEditorInput';
-import { ICreateWebViewShowOptions, IWebviewEditorService, WebviewInputOptions, WebviewReviver } from 'vs/workbench/parts/webview/electron-browser/webviewEditorService';
-import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { CodeInsetController } from 'vs/workbench/contrib/codeinset/electron-browser/codeInset.contribution';
+import { WebviewEditor } from 'vs/workbench/contrib/webview/electron-browser/webviewEditor';
+import { WebviewEditorInput } from 'vs/workbench/contrib/webview/electron-browser/webviewEditorInput';
+import { ICreateWebViewShowOptions, IWebviewEditorService, WebviewInputOptions } from 'vs/workbench/contrib/webview/electron-browser/webviewEditorService';
+import { WebviewElement } from 'vs/workbench/contrib/webview/electron-browser/webviewElement';
+import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { ACTIVE_GROUP, IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
-import { IEditorGroupsService } from 'vs/workbench/services/group/common/editorGroupsService';
+import { IWorkbenchLayoutService, Parts } from 'vs/workbench/services/layout/browser/layoutService';
 import * as vscode from 'vscode';
 import { extHostNamedCustomer } from './extHostCustomers';
-import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { onUnexpectedError } from 'vs/base/common/errors';
-import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';

@extHostNamedCustomer(MainContext.MainThreadWebviews)
-export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviver {
-
-	private static readonly viewType = 'mainThreadWebview';
+export class MainThreadWebviews extends Disposable implements MainThreadWebviewsShape {

 	private static readonly standardSupportedLinkSchemes = ['http', 'https', 'mailto'];

 	private static revivalPool = 0;

-	private _toDispose: IDisposable[] = [];

 	private readonly _proxy: ExtHostWebviewsShape;
 	private readonly _webviews = new Map<WebviewPanelHandle, WebviewEditorInput>();
-	private readonly _revivers = new Set<string>();
+	private readonly _webviewsElements = new Map<WebviewInsetHandle, WebviewElement>();
+	private readonly _revivers = new Map<string, IDisposable>();

 	private _activeWebview: WebviewPanelHandle | undefined = undefined;

 	constructor(
 		context: IExtHostContext,
 		@ILifecycleService lifecycleService: ILifecycleService,
+		@IExtensionService extensionService: IExtensionService,
 		@IEditorGroupsService private readonly _editorGroupService: IEditorGroupsService,
 		@IEditorService private readonly _editorService: IEditorService,
 		@IWebviewEditorService private readonly _webviewService: IWebviewEditorService,
 		@IOpenerService private readonly _openerService: IOpenerService,
-		@IExtensionService private readonly _extensionService: IExtensionService,
-		@ITelemetryService private readonly _telemetryService: ITelemetryService
+		@ITelemetryService private readonly _telemetryService: ITelemetryService,
+		@IInstantiationService private readonly _instantiationService: IInstantiationService,
+		@ICodeEditorService private readonly _codeEditorService: ICodeEditorService,
+		@IWorkbenchLayoutService private readonly _layoutService: IWorkbenchLayoutService,
 	) {
+		super();
+
 		this._proxy = context.getProxy(ExtHostContext.ExtHostWebviews);
 		_editorService.onDidActiveEditorChange(this.onActiveEditorChanged, this, this._toDispose);
 		_editorService.onDidVisibleEditorsChange(this.onVisibleEditorsChanged, this, this._toDispose);

-		this._toDispose.push(_webviewService.registerReviver(MainThreadWebviews.viewType, this));
+		// This reviver's only job is to activate webview extensions
+		// This should trigger the real reviver to be registered from the extension host side.
+		this._toDispose.push(_webviewService.registerReviver({
+			canRevive: (webview) => {
+				const viewType = webview.state.viewType;
+				if (viewType) {
+					extensionService.activateByEvent(`onWebviewPanel:${viewType}`);
+				}
+				return false;
+			},
+			reviveWebview: () => { throw new Error('not implemented'); }
+		}));

 		lifecycleService.onBeforeShutdown(e => {
 			e.veto(this._onBeforeShutdown());
 		}, this, this._toDispose);
 	}

-	public dispose(): void {
-		this._toDispose = dispose(this._toDispose);
-	}
-
 	public $createWebviewPanel(
 		handle: WebviewPanelHandle,
 		viewType: string,
 		title: string,
-		showOptions: { viewColumn: EditorViewColumn | null, preserveFocus: boolean },
+		showOptions: { viewColumn?: EditorViewColumn, preserveFocus?: boolean },
 		options: WebviewInputOptions,
 		extensionId: ExtensionIdentifier,
 		extensionLocation: UriComponents
 	): void {
 		const mainThreadShowOptions: ICreateWebViewShowOptions = Object.create(null);
 		if (showOptions) {
-			mainThreadShowOptions.preserveFocus = showOptions.preserveFocus;
+			mainThreadShowOptions.preserveFocus = !!showOptions.preserveFocus;
 			mainThreadShowOptions.group = viewColumnToEditorGroup(this._editorGroupService, showOptions.viewColumn);
 		}

-		const webview = this._webviewService.createWebview(MainThreadWebviews.viewType, title, mainThreadShowOptions, reviveWebviewOptions(options), URI.revive(extensionLocation), this.createWebviewEventDelegate(handle));
+		const webview = this._webviewService.createWebview(this.getInternalWebviewId(viewType), title, mainThreadShowOptions, reviveWebviewOptions(options), URI.revive(extensionLocation), this.createWebviewEventDelegate(handle));
 		webview.state = {
 			viewType: viewType,
 			state: undefined
@@ -96,6 +111,44 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 		this._telemetryService.publicLog('webviews:createWebviewPanel', { extensionId: extensionId.value });
 	}

+	$createWebviewCodeInset(handle: WebviewInsetHandle, symbolId: string, options: vscode.WebviewOptions, extensionLocation: UriComponents): void {
+		// todo@joh main is for the lack of a code-inset service
+		// which we maybe wanna have... this is how it now works
+		// 1) create webview element
+		// 2) find the code inset controller that request it
+		// 3) let the controller adopt the widget
+		// 4) continue to forward messages to the webview
+		const webview = this._instantiationService.createInstance(
+			WebviewElement,
+			this._layoutService.getContainer(Parts.EDITOR_PART),
+			{
+				extensionLocation: URI.revive(extensionLocation),
+				enableFindWidget: false,
+			},
+			{
+				allowScripts: options.enableScripts,
+			}
+		);
+
+		let found = false;
+		for (const editor of this._codeEditorService.listCodeEditors()) {
+			const ctrl = CodeInsetController.get(editor);
+			if (ctrl && ctrl.acceptWebview(symbolId, webview)) {
+				found = true;
+				break;
+			}
+		}
+
+		if (!found) {
+			webview.dispose();
+			return;
+		}
+		// this will leak... the adopted webview will be disposed by the
+		// code inset controller. we might need a dispose-event here so that
+		// we can clean up things.
+		this._webviewsElements.set(handle, webview);
+	}
+
 	public $disposeWebview(handle: WebviewPanelHandle): void {
 		const webview = this.getWebview(handle);
 		webview.dispose();
@@ -111,14 +164,22 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 		webview.iconPath = reviveWebviewIcon(value);
 	}

-	public $setHtml(handle: WebviewPanelHandle, value: string): void {
-		const webview = this.getWebview(handle);
-		webview.html = value;
+	public $setHtml(handle: WebviewPanelHandle | WebviewInsetHandle, value: string): void {
+		if (typeof handle === 'number') {
+			this.getWebviewElement(handle).contents = value;
+		} else {
+			const webview = this.getWebview(handle);
+			webview.html = value;
+		}
 	}

-	public $setOptions(handle: WebviewPanelHandle, options: vscode.WebviewOptions): void {
-		const webview = this.getWebview(handle);
-		webview.setOptions(reviveWebviewOptions(options));
+	public $setOptions(handle: WebviewPanelHandle | WebviewInsetHandle, options: vscode.WebviewOptions): void {
+		if (typeof handle === 'number') {
+			this.getWebviewElement(handle).options = reviveWebviewOptions(options);
+		} else {
+			const webview = this.getWebview(handle);
+			webview.setOptions(reviveWebviewOptions(options));
+		}
 	}

 	public $reveal(handle: WebviewPanelHandle, showOptions: WebviewPanelShowOptions): void {
@@ -128,69 +189,82 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 		}

 		const targetGroup = this._editorGroupService.getGroup(viewColumnToEditorGroup(this._editorGroupService, showOptions.viewColumn));
-
-		this._webviewService.revealWebview(webview, targetGroup || this._editorGroupService.activeGroup, showOptions.preserveFocus);
+		if (targetGroup) {
+			this._webviewService.revealWebview(webview, targetGroup || this._editorGroupService.getGroup(webview.group || ACTIVE_GROUP), !!showOptions.preserveFocus);
+		}
 	}

-	public $postMessage(handle: WebviewPanelHandle, message: any): Promise<boolean> {
-		const webview = this.getWebview(handle);
-		const editors = this._editorService.visibleControls
-			.filter(e => e instanceof WebviewEditor)
-			.map(e => e as WebviewEditor)
-			.filter(e => e.input.matches(webview));
+	public $postMessage(handle: WebviewPanelHandle | WebviewInsetHandle, message: any): Promise<boolean> {
+		if (typeof handle === 'number') {
+			this.getWebviewElement(handle).sendMessage(message);
+			return Promise.resolve(true);

-		for (const editor of editors) {
-			editor.sendMessage(message);
+		} else {
+			const webview = this.getWebview(handle);
+			const editors = this._editorService.visibleControls
+				.filter(e => e instanceof WebviewEditor)
+				.map(e => e as WebviewEditor)
+				.filter(e => e.input!.matches(webview));
+
+			for (const editor of editors) {
+				editor.sendMessage(message);
+			}
+
+			return Promise.resolve(editors.length > 0);
 		}
-
-		return Promise.resolve(editors.length > 0);
 	}

 	public $registerSerializer(viewType: string): void {
-		this._revivers.add(viewType);
-	}
+		if (this._revivers.has(viewType)) {
+			throw new Error(`Reviver for ${viewType} already registered`);
+		}

-	public $unregisterSerializer(viewType: string): void {
-		this._revivers.delete(viewType);
-	}
+		this._revivers.set(viewType, this._webviewService.registerReviver({
+			canRevive: (webview) => {
+				return webview.state && webview.state.viewType === viewType;
+			},
+			reviveWebview: async (webview): Promise<void> => {
+				const viewType = webview.state.viewType;
+				const handle = 'revival-' + MainThreadWebviews.revivalPool++;
+				this._webviews.set(handle, webview);
+				webview._events = this.createWebviewEventDelegate(handle);
+				let state = undefined;
+				if (webview.state.state) {
+					try {
+						state = JSON.parse(webview.state.state);
+					} catch {
+						// noop
+					}
+				}

-	public reviveWebview(webview: WebviewEditorInput): Promise<void> {
-		const viewType = webview.state.viewType;
-		return Promise.resolve(this._extensionService.activateByEvent(`onWebviewPanel:${viewType}`).then(() => {
-			const handle = 'revival-' + MainThreadWebviews.revivalPool++;
-			this._webviews.set(handle, webview);
-			webview._events = this.createWebviewEventDelegate(handle);
-
-			let state = undefined;
-			if (webview.state.state) {
 				try {
-					state = JSON.parse(webview.state.state);
-				} catch {
-					// noop
+					await this._proxy.$deserializeWebviewPanel(handle, viewType, webview.getTitle(), state, editorGroupToViewColumn(this._editorGroupService, webview.group || ACTIVE_GROUP), webview.options);
+				} catch (error) {
+					onUnexpectedError(error);
+					webview.html = MainThreadWebviews.getDeserializationFailedContents(viewType);
 				}
 			}
-
-			return this._proxy.$deserializeWebviewPanel(handle, webview.state.viewType, webview.getTitle(), state, editorGroupToViewColumn(this._editorGroupService, webview.group), webview.options)
-				.then(undefined, error => {
-					onUnexpectedError(error);
-
-					webview.html = MainThreadWebviews.getDeserializationFailedContents(viewType);
-				});
 		}));
 	}

-	public canRevive(webview: WebviewEditorInput): boolean {
-		if (webview.isDisposed() || !webview.state) {
-			return false;
+	public $unregisterSerializer(viewType: string): void {
+		const reviver = this._revivers.get(viewType);
+		if (!reviver) {
+			throw new Error(`No reviver for ${viewType} registered`);
 		}

-		return this._revivers.has(webview.state.viewType) || !!webview.reviver;
+		reviver.dispose();
+		this._revivers.delete(viewType);
+	}
+
+	private getInternalWebviewId(viewType: string): string {
+		return `mainThreadWebview-${viewType}`;
 	}

 	private _onBeforeShutdown(): boolean {
-		this._webviews.forEach((view) => {
-			if (this.canRevive(view)) {
-				view.state.state = view.webviewState;
+		this._webviews.forEach((webview) => {
+			if (!webview.isDisposed() && webview.state && this._revivers.has(webview.state.viewType)) {
+				webview.state.state = webview.webviewState;
 			}
 		});
 		return false; // Don't veto shutdown
@@ -201,12 +275,9 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 			onDidClickLink: uri => this.onDidClickLink(handle, uri),
 			onMessage: message => this._proxy.$onMessage(handle, message),
 			onDispose: () => {
-				const cleanUp = () => {
+				this._proxy.$onDidDisposeWebviewPanel(handle).finally(() => {
 					this._webviews.delete(handle);
-				};
-				this._proxy.$onDidDisposeWebviewPanel(handle).then(
-					cleanUp,
-					cleanUp);
+				});
 			}
 		};
 	}
@@ -216,7 +287,7 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 		let newActiveWebview: { input: WebviewEditorInput, handle: WebviewPanelHandle } | undefined = undefined;
 		if (activeEditor && activeEditor.input instanceof WebviewEditorInput) {
 			for (const handle of map.keys(this._webviews)) {
-				const input = this._webviews.get(handle);
+				const input = this._webviews.get(handle)!;
 				if (input.matches(activeEditor.input)) {
 					newActiveWebview = { input, handle };
 					break;
@@ -229,7 +300,7 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 			this._proxy.$onDidChangeWebviewPanelViewState(newActiveWebview.handle, {
 				active: true,
 				visible: true,
-				position: editorGroupToViewColumn(this._editorGroupService, newActiveWebview.input.group)
+				position: editorGroupToViewColumn(this._editorGroupService, newActiveWebview.input.group || ACTIVE_GROUP)
 			});
 			return;
 		}
@@ -240,8 +311,8 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 			if (oldActiveWebview) {
 				this._proxy.$onDidChangeWebviewPanelViewState(this._activeWebview, {
 					active: false,
-					visible: this._editorService.visibleControls.some(editor => editor.input && editor.input.matches(oldActiveWebview)),
-					position: editorGroupToViewColumn(this._editorGroupService, oldActiveWebview.group),
+					visible: this._editorService.visibleControls.some(editor => !!editor.input && editor.input.matches(oldActiveWebview)),
+					position: editorGroupToViewColumn(this._editorGroupService, oldActiveWebview.group || ACTIVE_GROUP),
 				});
 			}
 		}
@@ -251,7 +322,7 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 			this._proxy.$onDidChangeWebviewPanelViewState(newActiveWebview.handle, {
 				active: true,
 				visible: true,
-				position: editorGroupToViewColumn(this._editorGroupService, activeEditor.group)
+				position: editorGroupToViewColumn(this._editorGroupService, activeEditor ? activeEditor.group : ACTIVE_GROUP),
 			});
 			this._activeWebview = newActiveWebview.handle;
 		} else {
@@ -263,9 +334,9 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 		this._webviews.forEach((input, handle) => {
 			for (const workbenchEditor of this._editorService.visibleControls) {
 				if (workbenchEditor.input && workbenchEditor.input.matches(input)) {
-					const editorPosition = editorGroupToViewColumn(this._editorGroupService, workbenchEditor.group);
+					const editorPosition = editorGroupToViewColumn(this._editorGroupService, workbenchEditor.group!);

-					input.updateGroup(workbenchEditor.group.id);
+					input.updateGroup(workbenchEditor.group!.id);
 					this._proxy.$onDidChangeWebviewPanelViewState(handle, {
 						active: handle === this._activeWebview,
 						visible: true,
@@ -297,6 +368,14 @@ export class MainThreadWebviews implements MainThreadWebviewsShape, WebviewReviv
 		return webview;
 	}

+	private getWebviewElement(handle: number): WebviewElement {
+		const webview = this._webviewsElements.get(handle);
+		if (!webview) {
+			throw new Error('Unknown webview handle:' + handle);
+		}
+		return webview;
+	}
+
 	private static getDeserializationFailedContents(viewType: string) {
 		return `<!DOCTYPE html>
 		<html>