Merge from vscode 718331d6f3ebd1b571530ab499edb266ddd493d5

src/vs/workbench/api/browser/extensionHost.contribution.ts

@@ -60,6 +60,7 @@ import './mainThreadComments';
 import './mainThreadLabelService';
 import './mainThreadTunnelService';
 import './mainThreadAuthentication';
+import './mainThreadTimeline';
 import 'vs/workbench/api/common/apiCommands';
 
 export class ExtensionPoints implements IWorkbenchContribution {

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

@@ -20,12 +20,24 @@ export class MainThreadAuthenticationProvider {
 		public readonly displayName: string
 	) { }
 
-	getSessions(): Promise<ReadonlyArray<modes.Session>> {
-		return this._proxy.$getSessions(this.id);
+	async getSessions(): Promise<ReadonlyArray<modes.AuthenticationSession>> {
+		return (await this._proxy.$getSessions(this.id)).map(session => {
+			return {
+				id: session.id,
+				accountName: session.accountName,
+				accessToken: () => this._proxy.$getSessionAccessToken(this.id, session.id)
+			};
+		});
 	}
 
-	login(scopes: string[]): Promise<modes.Session> {
-		return this._proxy.$login(this.id, scopes);
+	login(scopes: string[]): Promise<modes.AuthenticationSession> {
+		return this._proxy.$login(this.id, scopes).then(session => {
+			return {
+				id: session.id,
+				accountName: session.accountName,
+				accessToken: () => this._proxy.$getSessionAccessToken(this.id, session.id)
+			};
+		});
 	}
 
 	logout(accountId: string): Promise<void> {

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

@@ -77,7 +77,7 @@ export class MainThreadConfiguration implements MainThreadConfigurationShape {
 			: scopeToLanguage === false ? { resource: overrides.resource }
 				: overrides.overrideIdentifier && overriddenValue !== undefined ? overrides
 					: { resource: overrides.resource };
-		return this.configurationService.updateValue(key, value, overrides, configurationTarget);
+		return this.configurationService.updateValue(key, value, overrides, configurationTarget, true);
 	}
 
 	private deriveConfigurationTarget(key: string, overrides: IConfigurationOverrides): ConfigurationTarget {

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

@@ -4,15 +4,14 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Registry } from 'vs/platform/registry/common/platform';
-import { IOutputService, IOutputChannel, OUTPUT_PANEL_ID } from 'vs/workbench/contrib/output/common/output';
+import { IOutputService, IOutputChannel, OUTPUT_VIEW_ID } from 'vs/workbench/contrib/output/common/output';
 import { Extensions, IOutputChannelRegistry } from 'vs/workbench/services/output/common/output';
-import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService';
-import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 import { MainThreadOutputServiceShape, MainContext, IExtHostContext, ExtHostOutputServiceShape, ExtHostContext } from '../common/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { UriComponents, URI } from 'vs/base/common/uri';
 import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { Event } from 'vs/base/common/event';
+import { IViewsService } from 'vs/workbench/common/views';
 
 @extHostNamedCustomer(MainContext.MainThreadOutputService)
 export class MainThreadOutputService extends Disposable implements MainThreadOutputServiceShape {
@@ -21,28 +20,24 @@ export class MainThreadOutputService extends Disposable implements MainThreadOut
 
 	private readonly _proxy: ExtHostOutputServiceShape;
 	private readonly _outputService: IOutputService;
-	private readonly _layoutService: IWorkbenchLayoutService;
-	private readonly _panelService: IPanelService;
+	private readonly _viewsService: IViewsService;
 
 	constructor(
 		extHostContext: IExtHostContext,
 		@IOutputService outputService: IOutputService,
-		@IWorkbenchLayoutService layoutService: IWorkbenchLayoutService,
-		@IPanelService panelService: IPanelService
+		@IViewsService viewsService: IViewsService
 	) {
 		super();
 		this._outputService = outputService;
-		this._layoutService = layoutService;
-		this._panelService = panelService;
+		this._viewsService = viewsService;
 
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostOutputService);
 
 		const setVisibleChannel = () => {
-			const panel = this._panelService.getActivePanel();
-			const visibleChannel = panel && panel.getId() === OUTPUT_PANEL_ID ? this._outputService.getActiveChannel() : undefined;
+			const visibleChannel = this._viewsService.isViewVisible(OUTPUT_VIEW_ID) ? this._outputService.getActiveChannel() : undefined;
 			this._proxy.$setVisibleChannel(visibleChannel ? visibleChannel.id : null);
 		};
-		this._register(Event.any<any>(this._outputService.onActiveOutputChannel, this._panelService.onDidPanelOpen, this._panelService.onDidPanelClose)(() => setVisibleChannel()));
+		this._register(Event.any<any>(this._outputService.onActiveOutputChannel, Event.filter(this._viewsService.onDidChangeViewVisibility, ({ id }) => id === OUTPUT_VIEW_ID))(() => setVisibleChannel()));
 		setVisibleChannel();
 	}
 
@@ -86,11 +81,10 @@ export class MainThreadOutputService extends Disposable implements MainThreadOut
 	}
 
 	public $close(channelId: string): Promise<void> | undefined {
-		const panel = this._panelService.getActivePanel();
-		if (panel && panel.getId() === OUTPUT_PANEL_ID) {
+		if (this._viewsService.isViewVisible(OUTPUT_VIEW_ID)) {
 			const activeChannel = this._outputService.getActiveChannel();
 			if (activeChannel && channelId === activeChannel.id) {
-				this._layoutService.setPanelHidden(true);
+				this._viewsService.closeView(OUTPUT_VIEW_ID);
 			}
 		}
 

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

@@ -202,8 +202,8 @@ class MainThreadSCMProvider implements ISCMProvider {
 					const icon = icons[0];
 					const iconDark = icons[1] || icon;
 					const decorations = {
-						icon: icon ? URI.parse(icon) : undefined,
-						iconDark: iconDark ? URI.parse(iconDark) : undefined,
+						icon: icon ? URI.revive(icon) : undefined,
+						iconDark: iconDark ? URI.revive(iconDark) : undefined,
 						tooltip,
 						strikeThrough,
 						faded

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

@@ -3,7 +3,7 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IdleValue } from 'vs/base/common/async';
+import { IdleValue, raceCancellation } from 'vs/base/common/async';
 import { CancellationTokenSource, CancellationToken } from 'vs/base/common/cancellation';
 import * as strings from 'vs/base/common/strings';
 import { IActiveCodeEditor } from 'vs/editor/browser/editorBrowser';
@@ -22,25 +22,20 @@ import { CodeActionKind } from 'vs/editor/contrib/codeAction/types';
 import { formatDocumentWithSelectedProvider, FormattingMode } from 'vs/editor/contrib/format/format';
 import { SnippetController2 } from 'vs/editor/contrib/snippet/snippetController2';
 import { localize } from 'vs/nls';
-import { CommandsRegistry } from 'vs/platform/commands/common/commands';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IProgressService, ProgressLocation, IProgressStep, IProgress } from 'vs/platform/progress/common/progress';
 import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
-import { TextFileEditorModel } from 'vs/workbench/services/textfile/common/textFileEditorModel';
-import { ISaveParticipant, IResolvedTextFileEditorModel, ITextFileEditorModel } from 'vs/workbench/services/textfile/common/textfiles';
+import { ISaveParticipant, IResolvedTextFileEditorModel, ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
 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 { 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 } from 'vs/base/common/errors';
+import { INotebookService } from 'sql/workbench/services/notebook/browser/notebookService';
 
-export interface ICodeActionsOnSaveOptions {
-	[kind: string]: boolean;
+export interface ISaveParticipantParticipant {
+	participate(model: IResolvedTextFileEditorModel, env: { reason: SaveReason }, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
 }
 
 /*
@@ -57,7 +52,7 @@ class NotebookUpdateParticipant implements ISaveParticipantParticipant { // {{SQ
 		// Nothing
 	}
 
-	public participate(model: ITextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
+	public participate(model: IResolvedTextFileEditorModel, env: { reason: SaveReason }): Promise<void> {
 		let uri = model.resource;
 		let notebookEditor = this.notebookService.findNotebookEditor(uri);
 		if (notebookEditor) {
@@ -67,10 +62,6 @@ class NotebookUpdateParticipant implements ISaveParticipantParticipant { // {{SQ
 	}
 }
 
-export interface ISaveParticipantParticipant {
-	participate(model: IResolvedTextFileEditorModel, env: { reason: SaveReason }, progress: IProgress<IProgressStep>, token: CancellationToken): Promise<void>;
-}
-
 class TrimWhitespaceParticipant implements ISaveParticipantParticipant {
 
 	constructor(
@@ -272,11 +263,10 @@ class CodeActionOnSaveParticipant implements ISaveParticipantParticipant {
 		if (env.reason === SaveReason.AUTO) {
 			return undefined;
 		}
-
 		const model = editorModel.textEditorModel;
 
 		const settingsOverrides = { overrideIdentifier: model.getLanguageIdentifier().language, resource: editorModel.resource };
-		const setting = this._configurationService.getValue<ICodeActionsOnSaveOptions>('editor.codeActionsOnSave', settingsOverrides);
+		const setting = this._configurationService.getValue<{ [kind: string]: boolean }>('editor.codeActionsOnSave', settingsOverrides);
 		if (!setting) {
 			return undefined;
 		}
@@ -381,6 +371,7 @@ export class SaveParticipant implements ISaveParticipant {
 		@IProgressService private readonly _progressService: IProgressService,
 		@ILogService private readonly _logService: ILogService,
 		@ILabelService private readonly _labelService: ILabelService,
+		@ITextFileService private readonly _textFileService: ITextFileService
 	) {
 		this._saveParticipants = new IdleValue(() => [
 			instantiationService.createInstance(TrimWhitespaceParticipant),
@@ -392,12 +383,12 @@ export class SaveParticipant implements ISaveParticipant {
 			instantiationService.createInstance(NotebookUpdateParticipant),
 			instantiationService.createInstance(ExtHostSaveParticipant, extHostContext),
 		]);
-		// Hook into model
-		TextFileEditorModel.setSaveParticipant(this);
+		// Set as save participant for all text files
+		this._textFileService.saveParticipant = this;
 	}
 
 	dispose(): void {
-		TextFileEditorModel.setSaveParticipant(null);
+		this._textFileService.saveParticipant = undefined;
 		this._saveParticipants.dispose();
 	}
 
@@ -411,32 +402,26 @@ export class SaveParticipant implements ISaveParticipant {
 			cancellable: true,
 			delay: model.isDirty() ? 3000 : 5000
 		}, async progress => {
+			// undoStop before participation
+			model.textEditorModel.pushStackElement();
 
 			for (let p of this._saveParticipants.getValue()) {
-
 				if (cts.token.isCancellationRequested) {
 					break;
 				}
 				try {
-					await p.participate(model, env, progress, cts.token);
+					const promise = p.participate(model, env, progress, cts.token);
+					await raceCancellation(promise, cts.token);
 				} catch (err) {
 					this._logService.warn(err);
 				}
 			}
 
+			// undoStop after participation
+			model.textEditorModel.pushStackElement();
 		}, () => {
 			// user cancel
 			cts.dispose(true);
 		});
 	}
 }
-
-CommandsRegistry.registerCommand('_showSettings', (accessor, ...args: any[]) => {
-	const [setting] = args;
-	const control = accessor.get(IEditorService).activeControl as SettingsEditor2;
-	if (control instanceof SettingsEditor2) {
-		control.focusSearch(`@tag:usesOnlineServices`);
-	} else {
-		accessor.get(IPreferencesService).openSettings(false, setting);
-	}
-});

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

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Emitter } from 'vs/base/common/event';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { URI } from 'vs/base/common/uri';
+import { ILogService } from 'vs/platform/log/common/log';
+import { MainContext, MainThreadTimelineShape, IExtHostContext, ExtHostTimelineShape, ExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ITimelineService, TimelineItem, TimelineProviderDescriptor, TimelineChangeEvent } from 'vs/workbench/contrib/timeline/common/timeline';
+
+@extHostNamedCustomer(MainContext.MainThreadTimeline)
+export class MainThreadTimeline implements MainThreadTimelineShape {
+	private readonly _proxy: ExtHostTimelineShape;
+	private readonly _providerEmitters = new Map<string, Emitter<TimelineChangeEvent>>();
+
+	constructor(
+		context: IExtHostContext,
+		@ILogService private readonly logService: ILogService,
+		@ITimelineService private readonly _timelineService: ITimelineService
+	) {
+		this._proxy = context.getProxy(ExtHostContext.ExtHostTimeline);
+	}
+
+	$getTimeline(uri: URI, token: CancellationToken): Promise<TimelineItem[]> {
+		return this._timelineService.getTimeline(uri, token);
+	}
+
+	$registerTimelineProvider(provider: TimelineProviderDescriptor): void {
+		this.logService.trace(`MainThreadTimeline#registerTimelineProvider: id=${provider.id}`);
+
+		const proxy = this._proxy;
+
+		const emitters = this._providerEmitters;
+		let onDidChange = emitters.get(provider.id);
+		if (onDidChange === undefined) {
+			onDidChange = new Emitter<TimelineChangeEvent>();
+			emitters.set(provider.id, onDidChange);
+		}
+
+		this._timelineService.registerTimelineProvider({
+			...provider,
+			onDidChange: onDidChange.event,
+			provideTimeline(uri: URI, token: CancellationToken) {
+				return proxy.$getTimeline(provider.id, uri, token);
+			},
+			dispose() {
+				emitters.delete(provider.id);
+				onDidChange?.dispose();
+			}
+		});
+	}
+
+	$unregisterTimelineProvider(id: string): void {
+		this.logService.trace(`MainThreadTimeline#unregisterTimelineProvider: id=${id}`);
+
+		this._timelineService.unregisterTimelineProvider(id);
+	}
+
+	$emitTimelineChangeEvent(e: TimelineChangeEvent): void {
+		this.logService.trace(`MainThreadTimeline#emitChangeEvent: id=${e.id}, uri=${e.uri?.toString(true)}`);
+
+		const emitter = this._providerEmitters.get(e.id!);
+		emitter?.fire(e);
+	}
+
+	dispose(): void {
+		// noop
+	}
+}

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

@@ -235,7 +235,7 @@ class ViewsExtensionHandler implements IWorkbenchContribution {
 		for (const viewContainer of viewContainersRegistry.all) {
 			if (viewContainer.extensionId && removedExtensions.has(ExtensionIdentifier.toKey(viewContainer.extensionId))) {
 				// move only those views that do not belong to the removed extension
-				const views = this.viewsRegistry.getViews(viewContainer).filter((view: ICustomViewDescriptor) => !removedExtensions.has(ExtensionIdentifier.toKey(view.extensionId)));
+				const views = this.viewsRegistry.getViews(viewContainer).filter(view => !removedExtensions.has(ExtensionIdentifier.toKey((view as ICustomViewDescriptor).extensionId)));
 				if (views.length) {
 					this.viewsRegistry.moveViews(views, this.getDefaultViewContainer());
 				}
@@ -290,7 +290,7 @@ class ViewsExtensionHandler implements IWorkbenchContribution {
 				const viewsToMove: IViewDescriptor[] = [];
 				for (const existingViewContainer of existingViewContainers) {
 					if (viewContainer !== existingViewContainer) {
-						viewsToMove.push(...this.viewsRegistry.getViews(existingViewContainer).filter((view: ICustomViewDescriptor) => view.originalContainerId === descriptor.id));
+						viewsToMove.push(...this.viewsRegistry.getViews(existingViewContainer).filter(view => (view as ICustomViewDescriptor).originalContainerId === descriptor.id));
 					}
 				}
 				if (viewsToMove.length) {
@@ -314,6 +314,7 @@ class ViewsExtensionHandler implements IWorkbenchContribution {
 					[id, `${id}.state`, { mergeViewWithContainerWhenSingleView: true }]
 				),
 				hideIfEmpty: true,
+				order,
 				icon,
 			}, ViewContainerLocation.Sidebar);
 
@@ -399,8 +400,9 @@ class ViewsExtensionHandler implements IWorkbenchContribution {
 						ctorDescriptor: new SyncDescriptor(CustomTreeViewPane),
 						when: ContextKeyExpr.deserialize(item.when),
 						canToggleVisibility: true,
+						canMoveView: true,
+						treeView: this.instantiationService.createInstance(CustomTreeView, item.id, item.name),
 						collapsed: this.showCollapsed(container),
-						treeView: this.instantiationService.createInstance(CustomTreeView, item.id, item.name, container),
 						order: order,
 						extensionId: extension.description.identifier,
 						originalContainerId: entry.key,
@@ -423,7 +425,7 @@ class ViewsExtensionHandler implements IWorkbenchContribution {
 	private removeViews(extensions: readonly IExtensionPointUser<ViewExtensionPointType>[]): void {
 		const removedExtensions: Set<string> = extensions.reduce((result, e) => { result.add(ExtensionIdentifier.toKey(e.description.identifier)); return result; }, new Set<string>());
 		for (const viewContainer of this.viewContainersRegistry.all) {
-			const removedViews = this.viewsRegistry.getViews(viewContainer).filter((v: ICustomViewDescriptor) => v.extensionId && removedExtensions.has(ExtensionIdentifier.toKey(v.extensionId)));
+			const removedViews = this.viewsRegistry.getViews(viewContainer).filter(v => (v as ICustomViewDescriptor).extensionId && removedExtensions.has(ExtensionIdentifier.toKey((v as ICustomViewDescriptor).extensionId)));
 			if (removedViews.length) {
 				this.viewsRegistry.deregisterViews(removedViews, viewContainer);
 			}