Merge from vscode 3c6f6af7347d38e87bc6406024e8dcf9e9bce229 (#8962)

* Merge from vscode 3c6f6af7347d38e87bc6406024e8dcf9e9bce229

* skip failing tests

* update mac build image

src/vs/workbench/api/browser/mainThreadAuthentication.ts

@@ -5,22 +5,27 @@
 
 import { Disposable } from 'vs/base/common/lifecycle';
 import * as modes from 'vs/editor/common/modes';
+import * as nls from 'vs/nls';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { IAuthenticationService } from 'vs/workbench/services/authentication/browser/authenticationService';
 import { ExtHostAuthenticationShape, ExtHostContext, IExtHostContext, MainContext, MainThreadAuthenticationShape } from '../common/extHost.protocol';
+import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
+import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import Severity from 'vs/base/common/severity';
 
 export class MainThreadAuthenticationProvider {
 	constructor(
 		private readonly _proxy: ExtHostAuthenticationShape,
-		public readonly id: string
+		public readonly id: string,
+		public readonly displayName: string
 	) { }
 
 	getSessions(): Promise<ReadonlyArray<modes.Session>> {
 		return this._proxy.$getSessions(this.id);
 	}
 
-	login(): Promise<modes.Session> {
-		return this._proxy.$login(this.id);
+	login(scopes: string[]): Promise<modes.Session> {
+		return this._proxy.$login(this.id, scopes);
 	}
 
 	logout(accountId: string): Promise<void> {
@@ -35,13 +40,15 @@ export class MainThreadAuthentication extends Disposable implements MainThreadAu
 	constructor(
 		extHostContext: IExtHostContext,
 		@IAuthenticationService private readonly authenticationService: IAuthenticationService,
+		@IDialogService private readonly dialogService: IDialogService,
+		@IStorageService private readonly storageService: IStorageService
 	) {
 		super();
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostAuthentication);
 	}
 
-	$registerAuthenticationProvider(id: string): void {
-		const provider = new MainThreadAuthenticationProvider(this._proxy, id);
+	$registerAuthenticationProvider(id: string, displayName: string): void {
+		const provider = new MainThreadAuthenticationProvider(this._proxy, id, displayName);
 		this.authenticationService.registerAuthenticationProvider(id, provider);
 	}
 
@@ -49,7 +56,55 @@ export class MainThreadAuthentication extends Disposable implements MainThreadAu
 		this.authenticationService.unregisterAuthenticationProvider(id);
 	}
 
-	$onDidChangeSessions(id: string) {
+	$onDidChangeSessions(id: string): void {
 		this.authenticationService.sessionsUpdate(id);
 	}
+
+	async $getSessionsPrompt(providerId: string, providerName: string, extensionId: string, extensionName: string): Promise<boolean> {
+		const alwaysAllow = this.storageService.get(`${extensionId}-${providerId}`, StorageScope.GLOBAL);
+		if (alwaysAllow) {
+			return true;
+		}
+
+		const { choice } = await this.dialogService.show(
+			Severity.Info,
+			nls.localize('confirmAuthenticationAccess', "The extension '{0}' is trying to access authentication information from {1}.", extensionName, providerName),
+			[nls.localize('cancel', "Cancel"), nls.localize('allow', "Allow"), nls.localize('alwaysAllow', "Always Allow"),],
+			{ cancelId: 0 }
+		);
+
+		switch (choice) {
+			case 1/** Allow */:
+				return true;
+			case 2 /** Always Allow */:
+				this.storageService.store(`${extensionId}-${providerId}`, 'true', StorageScope.GLOBAL);
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	async $loginPrompt(providerId: string, providerName: string, extensionId: string, extensionName: string): Promise<boolean> {
+		const alwaysAllow = this.storageService.get(`${extensionId}-${providerId}`, StorageScope.GLOBAL);
+		if (alwaysAllow) {
+			return true;
+		}
+
+		const { choice } = await this.dialogService.show(
+			Severity.Info,
+			nls.localize('confirmLogin', "The extension '{0}' wants to sign in using {1}.", extensionName, providerName),
+			[nls.localize('cancel', "Cancel"), nls.localize('continue', "Continue"), nls.localize('neverAgain', "Don't Show Again")],
+			{ cancelId: 0 }
+		);
+
+		switch (choice) {
+			case 1/** Allow */:
+				return true;
+			case 2 /** Always Allow */:
+				this.storageService.store(`${extensionId}-${providerId}`, 'true', StorageScope.GLOBAL);
+				return true;
+			default:
+				return false;
+		}
+	}
 }

src/vs/workbench/api/browser/mainThreadConfiguration.ts

@@ -83,7 +83,7 @@ export class MainThreadConfiguration implements MainThreadConfigurationShape {
 	private deriveConfigurationTarget(key: string, overrides: IConfigurationOverrides): ConfigurationTarget {
 		if (overrides.resource && this._workspaceContextService.getWorkbenchState() === WorkbenchState.WORKSPACE) {
 			const configurationProperties = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration).getConfigurationProperties();
-			if (configurationProperties[key] && (configurationProperties[key].scope === ConfigurationScope.RESOURCE || configurationProperties[key].scope === ConfigurationScope.RESOURCE_LANGUAGE)) {
+			if (configurationProperties[key] && (configurationProperties[key].scope === ConfigurationScope.RESOURCE || configurationProperties[key].scope === ConfigurationScope.LANGUAGE_OVERRIDABLE)) {
 				return ConfigurationTarget.WORKSPACE_FOLDER;
 			}
 		}

src/vs/workbench/api/browser/mainThreadDiagnostics.ts

@@ -54,6 +54,9 @@ export class MainThreadDiagnostics implements MainThreadDiagnosticsShape {
 							relatedInformation.resource = URI.revive(relatedInformation.resource);
 						}
 					}
+					if (marker.code && typeof marker.code !== 'string') {
+						marker.code.link = URI.revive(marker.code.link);
+					}
 				}
 			}
 			this._markerService.changeOne(owner, URI.revive(uri), markers);

src/vs/workbench/api/browser/mainThreadDocuments.ts

@@ -160,7 +160,7 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {
 	// --- from extension host process
 
 	$trySaveDocument(uri: UriComponents): Promise<boolean> {
-		return this._textFileService.save(URI.revive(uri));
+		return this._textFileService.save(URI.revive(uri)).then(target => !!target);
 	}
 
 	$tryOpenDocument(_uri: UriComponents): Promise<any> {

src/vs/workbench/api/browser/mainThreadEditors.ts

@@ -216,7 +216,7 @@ export class MainThreadTextEditors implements MainThreadTextEditorsShape {
 	}
 
 	$tryApplyWorkspaceEdit(dto: IWorkspaceEditDto): Promise<boolean> {
-		const { edits } = reviveWorkspaceEditDto(dto);
+		const { edits } = reviveWorkspaceEditDto(dto)!;
 		return this._bulkEditService.apply({ edits }).then(() => true, _err => false);
 	}
 

src/vs/workbench/api/browser/mainThreadExtensionService.ts

@@ -12,7 +12,7 @@ import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensio
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { localize } from 'vs/nls';
 import { Action } from 'vs/base/common/actions';
-import { IExtensionEnablementService, EnablementState } from 'vs/workbench/services/extensionManagement/common/extensionManagement';
+import { IWorkbenchExtensionEnablementService, EnablementState } from 'vs/workbench/services/extensionManagement/common/extensionManagement';
 import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { IHostService } from 'vs/workbench/services/host/browser/host';
 import { IExtensionsWorkbenchService } from 'vs/workbench/contrib/extensions/common/extensions';
@@ -27,7 +27,7 @@ export class MainThreadExtensionService implements MainThreadExtensionServiceSha
 	private readonly _notificationService: INotificationService;
 	private readonly _extensionsWorkbenchService: IExtensionsWorkbenchService;
 	private readonly _hostService: IHostService;
-	private readonly _extensionEnablementService: IExtensionEnablementService;
+	private readonly _extensionEnablementService: IWorkbenchExtensionEnablementService;
 
 	constructor(
 		extHostContext: IExtHostContext,
@@ -35,7 +35,7 @@ export class MainThreadExtensionService implements MainThreadExtensionServiceSha
 		@INotificationService notificationService: INotificationService,
 		@IExtensionsWorkbenchService extensionsWorkbenchService: IExtensionsWorkbenchService,
 		@IHostService hostService: IHostService,
-		@IExtensionEnablementService extensionEnablementService: IExtensionEnablementService
+		@IWorkbenchExtensionEnablementService extensionEnablementService: IWorkbenchExtensionEnablementService
 	) {
 		this._extensionService = extensionService;
 		this._notificationService = notificationService;

src/vs/workbench/api/browser/mainThreadLanguageFeatures.ts

@@ -11,7 +11,7 @@ import * as search from 'vs/workbench/contrib/search/common/search';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { Position as EditorPosition } from 'vs/editor/common/core/position';
 import { Range as EditorRange, IRange } from 'vs/editor/common/core/range';
-import { ExtHostContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, MainContext, IExtHostContext, ILanguageConfigurationDto, IRegExpDto, IIndentationRuleDto, IOnEnterRuleDto, ILocationDto, IWorkspaceSymbolDto, reviveWorkspaceEditDto, IDocumentFilterDto, IDefinitionLinkDto, ISignatureHelpProviderMetadataDto, ILinkDto, ICallHierarchyItemDto, ISuggestDataDto, ICodeActionDto, ISuggestDataDtoField } from '../common/extHost.protocol';
+import { ExtHostContext, MainThreadLanguageFeaturesShape, ExtHostLanguageFeaturesShape, MainContext, IExtHostContext, ILanguageConfigurationDto, IRegExpDto, IIndentationRuleDto, IOnEnterRuleDto, ILocationDto, IWorkspaceSymbolDto, reviveWorkspaceEditDto, IDocumentFilterDto, IDefinitionLinkDto, ISignatureHelpProviderMetadataDto, ILinkDto, ICallHierarchyItemDto, ISuggestDataDto, ICodeActionDto, ISuggestDataDtoField, ISuggestResultDtoField } from '../common/extHost.protocol';
 import { LanguageConfigurationRegistry } from 'vs/editor/common/modes/languageConfigurationRegistry';
 import { LanguageConfiguration, IndentationRule, OnEnterRule } from 'vs/editor/common/modes/languageConfiguration';
 import { IModeService } from 'vs/editor/common/services/modeService';
@@ -316,7 +316,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 
 	$registerRenameSupport(handle: number, selector: IDocumentFilterDto[], supportResolveLocation: boolean): void {
 		this._registrations.set(handle, modes.RenameProviderRegistry.register(selector, <modes.RenameProvider>{
-			provideRenameEdits: (model: ITextModel, position: EditorPosition, newName: string, token: CancellationToken): Promise<modes.WorkspaceEdit> => {
+			provideRenameEdits: (model: ITextModel, position: EditorPosition, newName: string, token: CancellationToken) => {
 				return this._proxy.$provideRenameEdits(handle, model.uri, position, newName, token).then(reviveWorkspaceEditDto);
 			},
 			resolveRenameLocation: supportResolveLocation
@@ -340,7 +340,7 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 	private static _inflateSuggestDto(defaultRange: IRange | { insert: IRange, replace: IRange }, data: ISuggestDataDto): modes.CompletionItem {
 
 		return {
-			label: data[ISuggestDataDtoField.label],
+			label: data[ISuggestDataDtoField.label2] || data[ISuggestDataDtoField.label],
 			kind: data[ISuggestDataDtoField.kind],
 			tags: data[ISuggestDataDtoField.kindModifier],
 			detail: data[ISuggestDataDtoField.detail],
@@ -369,11 +369,15 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha
 						// {{SQL CARBON EDIT}} @todo anthonydresser 4/12/19 required because of strict null checks
 						return undefined;
 					}
+
 					return {
-						suggestions: result.b.map(d => MainThreadLanguageFeatures._inflateSuggestDto(result.a, d)),
-						incomplete: result.c,
-						isDetailsResolved: result.d,
-						dispose: () => typeof result.x === 'number' && this._proxy.$releaseCompletionItems(handle, result.x)
+						suggestions: result[ISuggestResultDtoField.completions].map(d => MainThreadLanguageFeatures._inflateSuggestDto(result[ISuggestResultDtoField.defaultRanges], d)),
+						incomplete: result[ISuggestResultDtoField.isIncomplete] || false,
+						dispose: () => {
+							if (typeof result.x === 'number') {
+								this._proxy.$releaseCompletionItems(handle, result.x);
+							}
+						}
 					};
 				});
 			}

src/vs/workbench/api/browser/mainThreadQuickOpen.ts

@@ -8,6 +8,7 @@ import { ExtHostContext, MainThreadQuickOpenShape, ExtHostQuickOpenShape, Transf
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { URI } from 'vs/base/common/uri';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { ThemeIcon } from 'vs/platform/theme/common/themeService';
 
 interface QuickInputSession {
 	input: IQuickInput;
@@ -185,14 +186,22 @@ export class MainThreadQuickOpen implements MainThreadQuickOpenShape {
 						return this._quickInputService.backButton;
 					}
 					const { iconPath, tooltip, handle } = button;
-					return {
-						iconPath: iconPath && {
-							dark: URI.revive(iconPath.dark),
-							light: iconPath.light && URI.revive(iconPath.light)
-						},
-						tooltip,
-						handle
-					};
+					if ('id' in iconPath) {
+						return {
+							iconClass: ThemeIcon.asClassName(iconPath),
+							tooltip,
+							handle
+						};
+					} else {
+						return {
+							iconPath: {
+								dark: URI.revive(iconPath.dark),
+								light: iconPath.light && URI.revive(iconPath.light)
+							},
+							tooltip,
+							handle
+						};
+					}
 				});
 			} else {
 				(input as any)[param] = params[param];

src/vs/workbench/api/browser/mainThreadSaveParticipant.ts

@@ -33,23 +33,16 @@ import { ISaveParticipant, IResolvedTextFileEditorModel, ITextFileEditorModel }
 import { SaveReason } from 'vs/workbench/common/editor';
 import { ExtHostContext, ExtHostDocumentSaveParticipantShape, IExtHostContext } from '../common/extHost.protocol';
 import { INotebookService } from 'sql/workbench/services/notebook/browser/notebookService'; // {{SQL CARBON EDIT}}
-import { IStatusbarService, StatusbarAlignment } from 'vs/workbench/services/statusbar/common/statusbar';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { SettingsEditor2 } from 'vs/workbench/contrib/preferences/browser/settingsEditor2';
 import { IPreferencesService } from 'vs/workbench/services/preferences/common/preferences';
 import { ILabelService } from 'vs/platform/label/common/label';
-import { canceled, isPromiseCanceledError } from 'vs/base/common/errors';
+import { canceled } from 'vs/base/common/errors';
 
 export interface ICodeActionsOnSaveOptions {
 	[kind: string]: boolean;
 }
 
-class SaveParticipantError extends Error {
-	constructor(message: string, readonly setting?: string) {
-		super(message);
-	}
-}
-
 /*
  * An update participant that ensures any un-tracked changes are synced to the JSON file contents for a
  * Notebook before save occurs. While every effort is made to ensure model changes are notified and a listener
@@ -363,7 +356,7 @@ class ExtHostSaveParticipant implements ISaveParticipantParticipant {
 			token.onCancellationRequested(() => reject(canceled()));
 
 			setTimeout(
-				() => reject(new SaveParticipantError(localize('timeout.onWillSave', "Aborted onWillSaveTextDocument-event after 1750ms"))),
+				() => reject(new Error(localize('timeout.onWillSave', "Aborted onWillSaveTextDocument-event after 1750ms"))),
 				1750
 			);
 			this._proxy.$participateInSave(editorModel.resource, env.reason).then(values => {
@@ -386,7 +379,6 @@ export class SaveParticipant implements ISaveParticipant {
 		extHostContext: IExtHostContext,
 		@IInstantiationService instantiationService: IInstantiationService,
 		@IProgressService private readonly _progressService: IProgressService,
-		@IStatusbarService private readonly _statusbarService: IStatusbarService,
 		@ILogService private readonly _logService: ILogService,
 		@ILabelService private readonly _labelService: ILabelService,
 	) {
@@ -420,54 +412,23 @@ export class SaveParticipant implements ISaveParticipant {
 			delay: model.isDirty() ? 3000 : 5000
 		}, async progress => {
 
-			let firstError: SaveParticipantError | undefined;
 			for (let p of this._saveParticipants.getValue()) {
 
 				if (cts.token.isCancellationRequested) {
 					break;
 				}
-
 				try {
 					await p.participate(model, env, progress, cts.token);
-
 				} catch (err) {
-					if (!isPromiseCanceledError(err)) {
-						this._logService.warn(err);
-						firstError = !firstError && err instanceof SaveParticipantError ? err : firstError;
-					}
+					this._logService.warn(err);
 				}
 			}
 
-			if (firstError) {
-				this._showParticipantError(firstError);
-			}
-
 		}, () => {
 			// user cancel
 			cts.dispose(true);
 		});
 	}
-
-	private _showParticipantError(err: SaveParticipantError): void {
-
-		let entry: any = {
-			text: localize('title', "$(error) Save Participants Failed: {0}", err.message)
-		};
-		if (err.setting) {
-			entry.command = '_showSettings';
-			entry.arguments = [err.setting];
-		}
-
-		const handle = this._statusbarService.addEntry(
-			entry,
-			'saveParticipants.error',
-			localize('status.message', "Save Participants Errors"),
-			StatusbarAlignment.LEFT,
-			-Number.MAX_VALUE /* far right on left hand side */
-		);
-
-		setTimeout(() => handle.dispose(), 5000);
-	}
 }
 
 CommandsRegistry.registerCommand('_showSettings', (accessor, ...args: any[]) => {

src/vs/workbench/api/browser/mainThreadTunnelService.ts

@@ -8,9 +8,11 @@ import { TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { IRemoteExplorerService } from 'vs/workbench/services/remote/common/remoteExplorerService';
 import { ITunnelProvider, ITunnelService, TunnelOptions } from 'vs/platform/remote/common/tunnel';
+import { Disposable } from 'vs/base/common/lifecycle';
+import type { TunnelDescription } from 'vs/platform/remote/common/remoteAuthorityResolver';
 
 @extHostNamedCustomer(MainContext.MainThreadTunnelService)
-export class MainThreadTunnelService implements MainThreadTunnelServiceShape {
+export class MainThreadTunnelService extends Disposable implements MainThreadTunnelServiceShape {
 	private readonly _proxy: ExtHostTunnelServiceShape;
 
 	constructor(
@@ -18,7 +20,10 @@ export class MainThreadTunnelService implements MainThreadTunnelServiceShape {
 		@IRemoteExplorerService private readonly remoteExplorerService: IRemoteExplorerService,
 		@ITunnelService private readonly tunnelService: ITunnelService
 	) {
+		super();
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTunnelService);
+		this._register(tunnelService.onTunnelOpened(() => this._proxy.$onDidTunnelsChange()));
+		this._register(tunnelService.onTunnelClosed(() => this._proxy.$onDidTunnelsChange()));
 	}
 
 	async $openTunnel(tunnelOptions: TunnelOptions): Promise<TunnelDto | undefined> {
@@ -33,6 +38,15 @@ export class MainThreadTunnelService implements MainThreadTunnelServiceShape {
 		return this.remoteExplorerService.close(remote);
 	}
 
+	async $getTunnels(): Promise<TunnelDescription[]> {
+		return (await this.tunnelService.tunnels).map(tunnel => {
+			return {
+				remoteAddress: { port: tunnel.tunnelRemotePort, host: tunnel.tunnelRemoteHost },
+				localAddress: tunnel.localAddress
+			};
+		});
+	}
+
 	async $registerCandidateFinder(): Promise<void> {
 		this.remoteExplorerService.registerCandidateFinder(() => this._proxy.$findCandidatePorts());
 	}
@@ -59,7 +73,23 @@ export class MainThreadTunnelService implements MainThreadTunnelServiceShape {
 		this.tunnelService.setTunnelProvider(tunnelProvider);
 	}
 
+	async $setCandidateFilter(): Promise<void> {
+		this._register(this.remoteExplorerService.setCandidateFilter(async (candidates: { host: string, port: number, detail: string }[]): Promise<{ host: string, port: number, detail: string }[]> => {
+			const filters: boolean[] = await this._proxy.$filterCandidates(candidates);
+			const filteredCandidates: { host: string, port: number, detail: string }[] = [];
+			if (filters.length !== candidates.length) {
+				return candidates;
+			}
+			for (let i = 0; i < candidates.length; i++) {
+				if (filters[i]) {
+					filteredCandidates.push(candidates[i]);
+				}
+			}
+			return filteredCandidates;
+		}));
+	}
+
 	dispose(): void {
-		//
+
 	}
 }

src/vs/workbench/api/browser/mainThreadWebview.ts

@@ -3,6 +3,7 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { createCancelablePromise } from 'vs/base/common/async';
 import { onUnexpectedError } from 'vs/base/common/errors';
 import { Disposable, DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
 import { Schemas } from 'vs/base/common/network';
@@ -306,6 +307,8 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 
 		provider.dispose();
 		this._editorProviders.delete(viewType);
+
+		this._customEditorService.models.disposeAllModelsForView(viewType);
 	}
 
 	private async retainCustomEditorModel(webviewInput: WebviewInput, resource: URI, viewType: string, capabilities: readonly extHostProtocol.WebviewEditorCapabilities[]) {
@@ -323,21 +326,23 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 		const capabilitiesSet = new Set(capabilities);
 		const isEditable = capabilitiesSet.has(extHostProtocol.WebviewEditorCapabilities.Editable);
 		if (isEditable) {
-			model.onUndo(edits => {
-				this._proxy.$undoEdits(resource, viewType, edits.map(x => x.data));
+			model.onUndo(e => {
+				this._proxy.$undoEdits(resource, viewType, e.edits);
 			});
 
-			model.onApplyEdit(edits => {
-				const editsToApply = edits.filter(x => x.source !== model).map(x => x.data);
-				if (editsToApply.length) {
-					this._proxy.$applyEdits(resource, viewType, editsToApply);
+			model.onDisposeEdits(e => {
+				this._proxy.$disposeEdits(e.edits);
+			});
+
+			model.onApplyEdit(e => {
+				if (e.trigger !== model) {
+					this._proxy.$applyEdits(resource, viewType, e.edits);
 				}
 			});
 
 			model.onWillSave(e => {
 				e.waitUntil(this._proxy.$onSave(resource.toJSON(), viewType));
 			});
-
 		}
 
 		// Save as should always be implemented even if the model is readonly
@@ -349,6 +354,14 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 				e.waitUntil(this._fileService.copy(e.resource, e.targetResource, false /* overwrite */));
 			}
 		});
+
+		if (capabilitiesSet.has(extHostProtocol.WebviewEditorCapabilities.SupportsHotExit)) {
+			model.onBackup(() => {
+				return createCancelablePromise(token =>
+					this._proxy.$backup(model.resource.toJSON(), viewType, token));
+			});
+		}
+
 		return model;
 	}
 
@@ -365,13 +378,13 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 		}
 	}
 
-	public $onEdit(resource: UriComponents, viewType: string, editData: any): void {
+	public $onEdit(resource: UriComponents, viewType: string, editId: number): void {
 		const model = this._customEditorService.models.get(URI.revive(resource), viewType);
 		if (!model) {
 			throw new Error('Could not find model for webview editor');
 		}
 
-		model.pushEdit({ source: model, data: editData });
+		model.pushEdit(editId, model);
 	}
 
 	private hookupWebviewEventDelegate(handle: extHostProtocol.WebviewPanelHandle, input: WebviewInput) {

src/vs/workbench/api/browser/viewsExtensionPoint.ts

@@ -23,14 +23,7 @@ import { VIEWLET_ID as REMOTE } from 'vs/workbench/contrib/remote/common/remote.
 import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { URI } from 'vs/base/common/uri';
 import { ViewletRegistry, Extensions as ViewletExtensions, ShowViewletAction } from 'vs/workbench/browser/viewlet';
-import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
-import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService';
-import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
-import { IStorageService } from 'vs/platform/storage/common/storage';
-import { IThemeService } from 'vs/platform/theme/common/themeService';
-import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
 import { IViewletService } from 'vs/workbench/services/viewlet/browser/viewlet';
 import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
 import { IWorkbenchActionRegistry, Extensions as ActionExtensions } from 'vs/workbench/common/actions';
@@ -313,27 +306,13 @@ class ViewsExtensionHandler implements IWorkbenchContribution {
 
 		if (!viewContainer) {
 
-
-			class CustomViewPaneContainer extends ViewPaneContainer {
-				constructor(
-					@IWorkbenchLayoutService layoutService: IWorkbenchLayoutService,
-					@ITelemetryService telemetryService: ITelemetryService,
-					@IWorkspaceContextService protected contextService: IWorkspaceContextService,
-					@IStorageService protected storageService: IStorageService,
-					@IConfigurationService configurationService: IConfigurationService,
-					@IInstantiationService protected instantiationService: IInstantiationService,
-					@IThemeService themeService: IThemeService,
-					@IContextMenuService contextMenuService: IContextMenuService,
-					@IExtensionService extensionService: IExtensionService,
-				) {
-					super(id, `${id}.state`, { mergeViewWithContainerWhenSingleView: true }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService);
-				}
-			}
-
 			viewContainer = this.viewContainersRegistry.registerViewContainer({
 				id,
 				name: title, extensionId,
-				ctorDescriptor: new SyncDescriptor(CustomViewPaneContainer),
+				ctorDescriptor: new SyncDescriptor(
+					ViewPaneContainer,
+					[id, `${id}.state`, { mergeViewWithContainerWhenSingleView: true }]
+				),
 				hideIfEmpty: true,
 				icon,
 			}, ViewContainerLocation.Sidebar);