Merge remote-tracking branch 'origin/master' into rebornix/notebook

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

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

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/mainThreadSaveParticipant.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. 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,7 +22,6 @@ 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';
@@ -31,9 +30,6 @@ import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
 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 { 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';
 
@@ -391,7 +387,8 @@ export class SaveParticipant implements ISaveParticipant {
 					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);
 				}
@@ -403,13 +400,3 @@ export class SaveParticipant implements ISaveParticipant {
 		});
 	}
 }
-
-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 MIT License. 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 } 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<URI | undefined>>();
+
+	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: source=${provider.source}`);
+
+		const proxy = this._proxy;
+
+		const emitters = this._providerEmitters;
+		let onDidChange = emitters.get(provider.source);
+		if (onDidChange === undefined) {
+			onDidChange = new Emitter<URI | undefined>();
+			emitters.set(provider.source, onDidChange);
+		}
+
+		this._timelineService.registerTimelineProvider({
+			...provider,
+			onDidChange: onDidChange.event,
+			provideTimeline(uri: URI, token: CancellationToken) {
+				return proxy.$getTimeline(provider.source, uri, token);
+			},
+			dispose() {
+				emitters.delete(provider.source);
+				onDidChange?.dispose();
+			}
+		});
+	}
+
+	$unregisterTimelineProvider(source: string): void {
+		this.logService.trace(`MainThreadTimeline#unregisterTimelineProvider: source=${source}`);
+
+		this._timelineService.unregisterTimelineProvider(source);
+	}
+
+	$emitTimelineChangeEvent(source: string, uri: URI | undefined): void {
+		this.logService.trace(`MainThreadTimeline#emitChangeEvent: source=${source}, uri=${uri?.toString(true)}`);
+
+		const emitter = this._providerEmitters.get(source);
+		emitter?.fire(uri);
+	}
+
+	dispose(): void {
+		// noop
+	}
+}

src/vs/workbench/api/common/extHost.api.impl.ts

@@ -72,6 +72,7 @@ import { ExtHostTheming } from 'vs/workbench/api/common/extHostTheming';
 import { IExtHostTunnelService } from 'vs/workbench/api/common/extHostTunnelService';
 import { IExtHostApiDeprecationService } from 'vs/workbench/api/common/extHostApiDeprecationService';
 import { ExtHostAuthentication } from 'vs/workbench/api/common/extHostAuthentication';
+import { ExtHostTimeline } from 'vs/workbench/api/common/extHostTimeline';
 
 export interface IExtensionApiFactory {
 	(extension: IExtensionDescription, registry: ExtensionDescriptionRegistry, configProvider: ExtHostConfigProvider): typeof vscode;
@@ -134,6 +135,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const extHostNotebook = rpcProtocol.set(ExtHostContext.ExtHostNotebook, new ExtHostNotebookController(rpcProtocol, extHostDocumentsAndEditors));
 	const extHostTheming = rpcProtocol.set(ExtHostContext.ExtHostTheming, new ExtHostTheming(rpcProtocol));
 	const extHostAuthentication = rpcProtocol.set(ExtHostContext.ExtHostAuthentication, new ExtHostAuthentication(rpcProtocol));
+	const extHostTimeline = rpcProtocol.set(ExtHostContext.ExtHostTimeline, new ExtHostTimeline(rpcProtocol));
 
 	// Check that no named customers are missing
 	const expected: ProxyIdentifier<any>[] = values(ExtHostContext);
@@ -188,11 +190,8 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			get providers() {
 				return extHostAuthentication.providers(extension);
 			},
-			get onDidRegisterAuthenticationProvider() {
-				return extHostAuthentication.onDidRegisterAuthenticationProvider;
-			},
-			get onDidUnregisterAuthenticationProvider() {
-				return extHostAuthentication.onDidUnregisterAuthenticationProvider;
+			get onDidChangeAuthenticationProviders(): Event<vscode.AuthenticationProvidersChangeEvent> {
+				return extHostAuthentication.onDidChangeAuthenticationProviders;
 			}
 		};
 
@@ -769,6 +768,11 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			onDidTunnelsChange: (listener, thisArg?, disposables?) => {
 				checkProposedApiEnabled(extension);
 				return extHostTunnelService.onDidTunnelsChange(listener, thisArg, disposables);
+
+			},
+			registerTimelineProvider: (scheme: string, provider: vscode.TimelineProvider) => {
+				checkProposedApiEnabled(extension);
+				return extHostTimeline.registerTimelineProvider(provider, extHostCommands.converter);
 			}
 		};
 
@@ -992,7 +996,8 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			Decoration: extHostTypes.Decoration,
 			WebviewContentState: extHostTypes.WebviewContentState,
 			UIKind: UIKind,
-			ColorThemeKind: extHostTypes.ColorThemeKind
+			ColorThemeKind: extHostTypes.ColorThemeKind,
+			TimelineItem: extHostTypes.TimelineItem
 		};
 	};
 }

src/vs/workbench/api/common/extHost.protocol.ts

@@ -49,6 +49,7 @@ import { SaveReason } from 'vs/workbench/common/editor';
 import { ExtensionActivationReason } from 'vs/workbench/api/common/extHostExtensionActivator';
 import { TunnelDto } from 'vs/workbench/api/common/extHostTunnelService';
 import { TunnelOptions } from 'vs/platform/remote/common/tunnel';
+import { TimelineItem, TimelineProviderDescriptor } from 'vs/workbench/contrib/timeline/common/timeline';
 
 export interface IEnvironment {
 	isExtensionDevelopmentDebug: boolean;
@@ -812,6 +813,14 @@ export interface MainThreadTunnelServiceShape extends IDisposable {
 	$setCandidateFilter(): Promise<void>;
 }
 
+export interface MainThreadTimelineShape extends IDisposable {
+	$registerTimelineProvider(provider: TimelineProviderDescriptor): void;
+	$unregisterTimelineProvider(source: string): void;
+	$emitTimelineChangeEvent(source: string, uri: UriComponents | undefined): void;
+
+	$getTimeline(uri: UriComponents, token: CancellationToken): Promise<TimelineItem[]>;
+}
+
 // -- extension host
 
 export interface ExtHostCommandsShape {
@@ -1467,6 +1476,10 @@ export interface ExtHostTunnelServiceShape {
 	$onDidTunnelsChange(): Promise<void>;
 }
 
+export interface ExtHostTimelineShape {
+	$getTimeline(source: string, uri: UriComponents, token: CancellationToken): Promise<TimelineItem[]>;
+}
+
 // --- proxy identifiers
 
 export const MainContext = {
@@ -1511,7 +1524,8 @@ export const MainContext = {
 	MainThreadLabelService: createMainId<MainThreadLabelServiceShape>('MainThreadLabelService'),
 	MainThreadNotebook: createMainId<MainThreadNotebookShape>('MainThreadNotebook'),
 	MainThreadTheming: createMainId<MainThreadThemingShape>('MainThreadTheming'),
-	MainThreadTunnelService: createMainId<MainThreadTunnelServiceShape>('MainThreadTunnelService')
+	MainThreadTunnelService: createMainId<MainThreadTunnelServiceShape>('MainThreadTunnelService'),
+	MainThreadTimeline: createMainId<MainThreadTimelineShape>('MainThreadTimeline')
 };
 
 export const ExtHostContext = {
@@ -1549,5 +1563,6 @@ export const ExtHostContext = {
 	ExtHostNotebook: createMainId<ExtHostNotebookShape>('ExtHostNotebook'),
 	ExtHostTheming: createMainId<ExtHostThemingShape>('ExtHostTheming'),
 	ExtHostTunnelService: createMainId<ExtHostTunnelServiceShape>('ExtHostTunnelService'),
-	ExtHostAuthentication: createMainId<ExtHostAuthenticationShape>('ExtHostAuthentication')
+	ExtHostAuthentication: createMainId<ExtHostAuthenticationShape>('ExtHostAuthentication'),
+	ExtHostTimeline: createMainId<ExtHostTimelineShape>('ExtHostTimeline')
 };

src/vs/workbench/api/common/extHostAuthentication.ts

@@ -55,11 +55,8 @@ export class ExtHostAuthentication implements ExtHostAuthenticationShape {
 	private _proxy: MainThreadAuthenticationShape;
 	private _authenticationProviders: Map<string, vscode.AuthenticationProvider> = new Map<string, vscode.AuthenticationProvider>();
 
-	private _onDidRegisterAuthenticationProvider = new Emitter<string>();
-	readonly onDidRegisterAuthenticationProvider: Event<string> = this._onDidRegisterAuthenticationProvider.event;
-
-	private _onDidUnregisterAuthenticationProvider = new Emitter<string>();
-	readonly onDidUnregisterAuthenticationProvider: Event<string> = this._onDidUnregisterAuthenticationProvider.event;
+	private _onDidChangeAuthenticationProviders = new Emitter<vscode.AuthenticationProvidersChangeEvent>();
+	readonly onDidChangeAuthenticationProviders: Event<vscode.AuthenticationProvidersChangeEvent> = this._onDidChangeAuthenticationProviders.event;
 
 	constructor(mainContext: IMainContext) {
 		this._proxy = mainContext.getProxy(MainContext.MainThreadAuthentication);
@@ -83,13 +80,13 @@ export class ExtHostAuthentication implements ExtHostAuthenticationShape {
 		});
 
 		this._proxy.$registerAuthenticationProvider(provider.id, provider.displayName);
-		this._onDidRegisterAuthenticationProvider.fire(provider.id);
+		this._onDidChangeAuthenticationProviders.fire({ added: [provider.id], removed: [] });
 
 		return new Disposable(() => {
 			listener.dispose();
 			this._authenticationProviders.delete(provider.id);
 			this._proxy.$unregisterAuthenticationProvider(provider.id);
-			this._onDidUnregisterAuthenticationProvider.fire(provider.id);
+			this._onDidChangeAuthenticationProviders.fire({ added: [], removed: [provider.id] });
 		});
 	}
 

src/vs/workbench/api/common/extHostConfiguration.ts

@@ -42,7 +42,7 @@ type ConfigurationInspect<T> = {
 	workspaceFolderValue?: T,
 
 	defaultLanguageValue?: T;
-	userLanguageValue?: T;
+	globalLanguageValue?: T;
 	workspaceLanguageValue?: T;
 	workspaceFolderLanguageValue?: T;
 
@@ -260,13 +260,13 @@ export class ExtHostConfigProvider {
 					return {
 						key,
 
-						defaultValue: config.defaultValue,
-						globalValue: config.userValue,
-						workspaceValue: config.workspaceValue,
-						workspaceFolderValue: config.workspaceFolderValue,
+						defaultValue: config.default?.value,
+						globalValue: config.user?.value,
+						workspaceValue: config.workspace?.value,
+						workspaceFolderValue: config.workspaceFolder?.value,
 
 						defaultLanguageValue: config.default?.override,
-						userLanguageValue: config.user?.override,
+						globalLanguageValue: config.user?.override,
 						workspaceLanguageValue: config.workspace?.override,
 						workspaceFolderLanguageValue: config.workspaceFolder?.override,
 

src/vs/workbench/api/common/extHostTimeline.ts

@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { UriComponents, URI } from 'vs/base/common/uri';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { ExtHostTimelineShape, MainThreadTimelineShape, IMainContext, MainContext } from 'vs/workbench/api/common/extHost.protocol';
+import { TimelineItem, TimelineItemWithSource, TimelineProvider } from 'vs/workbench/contrib/timeline/common/timeline';
+import { IDisposable, toDisposable, DisposableStore } from 'vs/base/common/lifecycle';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { CommandsConverter } from 'vs/workbench/api/common/extHostCommands';
+import { ThemeIcon } from 'vs/workbench/api/common/extHostTypes';
+
+export interface IExtHostTimeline extends ExtHostTimelineShape {
+	readonly _serviceBrand: undefined;
+	$getTimeline(source: string, uri: UriComponents, token: vscode.CancellationToken): Promise<TimelineItem[]>;
+}
+
+export const IExtHostTimeline = createDecorator<IExtHostTimeline>('IExtHostTimeline');
+
+export class ExtHostTimeline implements IExtHostTimeline {
+	_serviceBrand: undefined;
+
+	private _proxy: MainThreadTimelineShape;
+
+	private _providers = new Map<string, TimelineProvider>();
+
+	constructor(
+		mainContext: IMainContext,
+	) {
+		this._proxy = mainContext.getProxy(MainContext.MainThreadTimeline);
+	}
+
+	async $getTimeline(source: string, uri: UriComponents, token: vscode.CancellationToken): Promise<TimelineItem[]> {
+		const provider = this._providers.get(source);
+		return provider?.provideTimeline(URI.revive(uri), token) ?? [];
+	}
+
+	registerTimelineProvider(provider: vscode.TimelineProvider, commandConverter: CommandsConverter): IDisposable {
+		const timelineDisposables = new DisposableStore();
+
+		const convertTimelineItem = this.convertTimelineItem(provider.source, commandConverter, timelineDisposables);
+
+		let disposable: IDisposable | undefined;
+		if (provider.onDidChange) {
+			disposable = provider.onDidChange(this.emitTimelineChangeEvent(provider.source), this);
+		}
+
+		return this.registerTimelineProviderCore({
+			...provider,
+			async provideTimeline(uri: URI, token: CancellationToken) {
+				timelineDisposables.clear();
+
+				const results = await provider.provideTimeline(uri, token);
+				// Intentional == we don't know how a provider will respond
+				// eslint-disable-next-line eqeqeq
+				return results != null
+					? results.map(item => convertTimelineItem(item))
+					: [];
+			},
+			dispose() {
+				disposable?.dispose();
+				timelineDisposables.dispose();
+			}
+		});
+	}
+
+	private convertTimelineItem(source: string, commandConverter: CommandsConverter, disposables: DisposableStore): (item: vscode.TimelineItem) => TimelineItemWithSource {
+		return (item: vscode.TimelineItem) => {
+			const { iconPath, ...props } = item;
+
+			let icon;
+			let iconDark;
+			let themeIcon;
+			if (item.iconPath) {
+				if (iconPath instanceof ThemeIcon) {
+					themeIcon = { id: iconPath.id };
+				}
+				else if (URI.isUri(iconPath)) {
+					icon = iconPath;
+					iconDark = iconPath;
+				}
+				else {
+					({ light: icon, dark: iconDark } = iconPath as { light: URI; dark: URI });
+				}
+			}
+
+			return {
+				...props,
+				source: source,
+				command: item.command ? commandConverter.toInternal(item.command, disposables) : undefined,
+				icon: icon,
+				iconDark: iconDark,
+				themeIcon: themeIcon
+			};
+		};
+	}
+
+	private emitTimelineChangeEvent(source: string) {
+		return (uri: vscode.Uri | undefined) => {
+			this._proxy.$emitTimelineChangeEvent(source, uri);
+		};
+	}
+
+	private registerTimelineProviderCore(provider: TimelineProvider): IDisposable {
+		// console.log(`ExtHostTimeline#registerTimelineProvider: source=${provider.source}`);
+
+		const existing = this._providers.get(provider.source);
+		if (existing && !existing.replaceable) {
+			throw new Error(`Timeline Provider ${provider.source} already exists.`);
+		}
+
+		this._proxy.$registerTimelineProvider({
+			source: provider.source,
+			sourceDescription: provider.sourceDescription,
+			replaceable: provider.replaceable
+		});
+		this._providers.set(provider.source, provider);
+
+		return toDisposable(() => {
+			this._providers.delete(provider.source);
+			this._proxy.$unregisterTimelineProvider(provider.source);
+			provider.dispose();
+		});
+	}
+}

src/vs/workbench/api/common/extHostTunnelService.ts

@@ -5,7 +5,7 @@
 
 import { ExtHostTunnelServiceShape } from 'vs/workbench/api/common/extHost.protocol';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
-import type * as vscode from 'vscode';
+import * as vscode from 'vscode';
 import { RemoteTunnel, TunnelOptions } from 'vs/platform/remote/common/tunnel';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { Emitter } from 'vs/base/common/event';

src/vs/workbench/api/common/extHostTypes.ts

@@ -2544,3 +2544,12 @@ export enum ColorThemeKind {
 }
 
 //#endregion Theming
+
+//#region Timeline
+
+@es5ClassCompat
+export class TimelineItem implements vscode.TimelineItem {
+	constructor(public label: string, public timestamp: number) { }
+}
+
+//#endregion Timeline

src/vs/workbench/api/common/extHostWorkspace.ts

@@ -25,7 +25,7 @@ import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
 import { Range, RelativePattern } from 'vs/workbench/api/common/extHostTypes';
 import { ITextQueryBuilderOptions } from 'vs/workbench/contrib/search/common/queryBuilder';
 import { IRawFileMatch2, resultIsMatch } from 'vs/workbench/services/search/common/search';
-import type * as vscode from 'vscode';
+import * as vscode from 'vscode';
 import { ExtHostWorkspaceShape, IWorkspaceData, MainContext, MainThreadMessageServiceShape, MainThreadWorkspaceShape } from './extHost.protocol';
 
 export interface IExtHostWorkspaceProvider {