Merge branch 'master' into tyriar/term_errors

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

@@ -41,6 +41,7 @@ import './mainThreadMessageService';
 import './mainThreadOutputService';
 import './mainThreadProgress';
 import './mainThreadQuickOpen';
+import './mainThreadRemoteConnectionData';
 import './mainThreadSaveParticipant';
 import './mainThreadSCM';
 import './mainThreadSearch';

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

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
+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';
@@ -12,8 +12,6 @@ import { ExtHostAuthenticationShape, ExtHostContext, IExtHostContext, MainContex
 import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import Severity from 'vs/base/common/severity';
-import { MenuRegistry, MenuId } from 'vs/platform/actions/common/actions';
-import { CommandsRegistry } from 'vs/platform/commands/common/commands';
 import { IQuickInputService } from 'vs/platform/quickinput/common/quickInput';
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { IStorageKeysSyncRegistryService } from 'vs/platform/userDataSync/common/storageKeys';
@@ -71,7 +69,6 @@ function addAccountUsage(storageService: IStorageService, providerId: string, ac
 }
 
 export class MainThreadAuthenticationProvider extends Disposable {
-	private _sessionMenuItems = new Map<string, IDisposable[]>();
 	private _accounts = new Map<string, string[]>(); // Map account name to session ids
 	private _sessions = new Map<string, string>(); // Map account id to name
 
@@ -82,7 +79,9 @@ export class MainThreadAuthenticationProvider extends Disposable {
 		public readonly supportsMultipleAccounts: boolean,
 		private readonly notificationService: INotificationService,
 		private readonly storageKeysSyncRegistryService: IStorageKeysSyncRegistryService,
-		private readonly storageService: IStorageService
+		private readonly storageService: IStorageService,
+		private readonly quickInputService: IQuickInputService,
+		private readonly dialogService: IDialogService
 	) {
 		super();
 	}
@@ -95,11 +94,11 @@ export class MainThreadAuthenticationProvider extends Disposable {
 		return !!this._sessions.size;
 	}
 
-	private manageTrustedExtensions(quickInputService: IQuickInputService, storageService: IStorageService, accountName: string) {
-		const quickPick = quickInputService.createQuickPick<{ label: string, description: string, extension: AllowedExtension }>();
+	public manageTrustedExtensions(accountName: string) {
+		const quickPick = this.quickInputService.createQuickPick<{ label: string, description: string, extension: AllowedExtension }>();
 		quickPick.canSelectMany = true;
-		const allowedExtensions = readAllowedExtensions(storageService, this.id, accountName);
-		const usages = readAccountUsages(storageService, this.id, accountName);
+		const allowedExtensions = readAllowedExtensions(this.storageService, this.id, accountName);
+		const usages = readAccountUsages(this.storageService, this.id, accountName);
 		const items = allowedExtensions.map(extension => {
 			const usage = usages.find(usage => extension.id === usage.extensionId);
 			return {
@@ -118,7 +117,7 @@ export class MainThreadAuthenticationProvider extends Disposable {
 
 		quickPick.onDidAccept(() => {
 			const updatedAllowedList = quickPick.selectedItems.map(item => item.extension);
-			storageService.store(`${this.id}-${accountName}`, JSON.stringify(updatedAllowedList), StorageScope.GLOBAL);
+			this.storageService.store(`${this.id}-${accountName}`, JSON.stringify(updatedAllowedList), StorageScope.GLOBAL);
 
 			quickPick.dispose();
 		});
@@ -146,69 +145,23 @@ export class MainThreadAuthenticationProvider extends Disposable {
 			this._accounts.set(session.account.displayName, [session.id]);
 		}
 
-		const menuItem = MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
-			group: '1_accounts',
-			command: {
-				id: `configureSessions${session.id}`,
-				title: `${session.account.displayName} (${this.displayName})`
-			},
-			order: 3
-		});
-
 		this.storageKeysSyncRegistryService.registerStorageKey({ key: `${this.id}-${session.account.displayName}`, version: 1 });
-
-		const manageCommand = CommandsRegistry.registerCommand({
-			id: `configureSessions${session.id}`,
-			handler: (accessor, args) => {
-				const quickInputService = accessor.get(IQuickInputService);
-				const storageService = accessor.get(IStorageService);
-				const dialogService = accessor.get(IDialogService);
-
-				const quickPick = quickInputService.createQuickPick();
-				const manage = nls.localize('manageTrustedExtensions', "Manage Trusted Extensions");
-				const signOut = nls.localize('signOut', "Sign Out");
-				const items = ([{ label: manage }, { label: signOut }]);
-
-				quickPick.items = items;
-
-				quickPick.onDidAccept(e => {
-					const selected = quickPick.selectedItems[0];
-					if (selected.label === signOut) {
-						this.signOut(dialogService, session);
-					}
-
-					if (selected.label === manage) {
-						this.manageTrustedExtensions(quickInputService, storageService, session.account.displayName);
-					}
-
-					quickPick.dispose();
-				});
-
-				quickPick.onDidHide(_ => {
-					quickPick.dispose();
-				});
-
-				quickPick.show();
-			},
-		});
-
-		this._sessionMenuItems.set(session.account.displayName, [menuItem, manageCommand]);
 	}
 
-	async signOut(dialogService: IDialogService, session: modes.AuthenticationSession): Promise<void> {
-		const accountUsages = readAccountUsages(this.storageService, this.id, session.account.displayName);
-		const sessionsForAccount = this._accounts.get(session.account.displayName);
+	async signOut(accountName: string): Promise<void> {
+		const accountUsages = readAccountUsages(this.storageService, this.id, accountName);
+		const sessionsForAccount = this._accounts.get(accountName);
 
-		const result = await dialogService.confirm({
-			title: nls.localize('signOutConfirm', "Sign out of {0}", session.account.displayName),
+		const result = await this.dialogService.confirm({
+			title: nls.localize('signOutConfirm', "Sign out of {0}", accountName),
 			message: accountUsages.length
-				? nls.localize('signOutMessagve', "The account {0} has been used by: \n\n{1}\n\n Sign out of these features?", session.account.displayName, accountUsages.map(usage => usage.extensionName).join('\n'))
-				: nls.localize('signOutMessageSimple', "Sign out of {0}?", session.account.displayName)
+				? nls.localize('signOutMessagve', "The account {0} has been used by: \n\n{1}\n\n Sign out of these features?", accountName, accountUsages.map(usage => usage.extensionName).join('\n'))
+				: nls.localize('signOutMessageSimple', "Sign out of {0}?", accountName)
 		});
 
 		if (result.confirmed) {
 			sessionsForAccount?.forEach(sessionId => this.logout(sessionId));
-			removeAccountUsage(this.storageService, this.id, session.account.displayName);
+			removeAccountUsage(this.storageService, this.id, accountName);
 		}
 	}
 
@@ -230,11 +183,6 @@ export class MainThreadAuthenticationProvider extends Disposable {
 				sessionsForAccount.splice(sessionIndex);
 
 				if (!sessionsForAccount.length) {
-					const disposeables = this._sessionMenuItems.get(accountName);
-					if (disposeables) {
-						disposeables.forEach(disposeable => disposeable.dispose());
-						this._sessionMenuItems.delete(accountName);
-					}
 					this._accounts.delete(accountName);
 				}
 			}
@@ -251,12 +199,6 @@ export class MainThreadAuthenticationProvider extends Disposable {
 		await this._proxy.$logout(this.id, sessionId);
 		this.notificationService.info(nls.localize('signedOut', "Successfully signed out."));
 	}
-
-	dispose(): void {
-		super.dispose();
-		this._sessionMenuItems.forEach(item => item.forEach(d => d.dispose()));
-		this._sessionMenuItems.clear();
-	}
 }
 
 @extHostNamedCustomer(MainContext.MainThreadAuthentication)
@@ -294,7 +236,7 @@ export class MainThreadAuthentication extends Disposable implements MainThreadAu
 	}
 
 	async $registerAuthenticationProvider(id: string, displayName: string, supportsMultipleAccounts: boolean): Promise<void> {
-		const provider = new MainThreadAuthenticationProvider(this._proxy, id, displayName, supportsMultipleAccounts, this.notificationService, this.storageKeysSyncRegistryService, this.storageService);
+		const provider = new MainThreadAuthenticationProvider(this._proxy, id, displayName, supportsMultipleAccounts, this.notificationService, this.storageKeysSyncRegistryService, this.storageService, this.quickInputService, this.dialogService);
 		await provider.initialize();
 		this.authenticationService.registerAuthenticationProvider(id, provider);
 	}

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

@@ -135,7 +135,7 @@ export class MainThreadEditorInsets implements MainThreadEditorInsetsShape {
 
 	async $postMessage(handle: number, value: any): Promise<boolean> {
 		const inset = this.getInset(handle);
-		inset.webview.sendMessage(value);
+		inset.webview.postMessage(value);
 		return true;
 	}
 

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ICommandService, CommandsRegistry, ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
-import { IDisposable } from 'vs/base/common/lifecycle';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { ExtHostContext, MainThreadCommandsShape, ExtHostCommandsShape, MainContext, IExtHostContext } from '../common/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { revive } from 'vs/base/common/marshalling';
@@ -28,7 +28,7 @@ export class MainThreadCommands implements MainThreadCommandsShape {
 	}
 
 	dispose() {
-		this._commandRegistrations.forEach(value => value.dispose());
+		dispose(this._commandRegistrations.values());
 		this._commandRegistrations.clear();
 
 		this._generateCommandsDocumentationRegistration.dispose();

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

@@ -229,7 +229,7 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape, IDeb
 		const folderUri = folder ? uri.revive(folder) : undefined;
 		const launch = this.debugService.getConfigurationManager().getLaunch(folderUri);
 		const debugOptions: IDebugSessionOptions = {
-			noDebug: false,
+			noDebug: options.noDebug,
 			parentSession: this.getSession(options.parentSessionID),
 			repl: options.repl
 		};

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { onUnexpectedError } from 'vs/base/common/errors';
-import { IDisposable } from 'vs/base/common/lifecycle';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { EditOperation } from 'vs/editor/common/core/editOperation';
 import { Range } from 'vs/editor/common/core/range';
@@ -35,8 +35,8 @@ export class MainThreadDocumentContentProviders implements MainThreadDocumentCon
 	}
 
 	dispose(): void {
-		this._resourceContentProvider.forEach(p => p.dispose());
-		this._pendingUpdate.forEach(source => source.dispose());
+		dispose(this._resourceContentProvider.values());
+		dispose(this._pendingUpdate.values());
 	}
 
 	$registerTextContentProvider(handle: number, scheme: string): void {

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

@@ -36,32 +36,32 @@ namespace delta {
 	export function ofSets<T>(before: Set<T>, after: Set<T>): { removed: T[], added: T[] } {
 		const removed: T[] = [];
 		const added: T[] = [];
-		before.forEach(element => {
+		for (let element of before) {
 			if (!after.has(element)) {
 				removed.push(element);
 			}
-		});
-		after.forEach(element => {
+		}
+		for (let element of after) {
 			if (!before.has(element)) {
 				added.push(element);
 			}
-		});
+		}
 		return { removed, added };
 	}
 
 	export function ofMaps<K, V>(before: Map<K, V>, after: Map<K, V>): { removed: V[], added: V[] } {
 		const removed: V[] = [];
 		const added: V[] = [];
-		before.forEach((value, index) => {
+		for (let [index, value] of before) {
 			if (!after.has(index)) {
 				removed.push(value);
 			}
-		});
-		after.forEach((value, index) => {
+		}
+		for (let [index, value] of after) {
 			if (!before.has(index)) {
 				added.push(value);
 			}
-		});
+		}
 		return { removed, added };
 	}
 }
@@ -266,11 +266,11 @@ class MainThreadDocumentAndEditorStateComputer {
 			}
 
 			if (candidate) {
-				editors.forEach(snapshot => {
+				for (const snapshot of editors.values()) {
 					if (candidate === snapshot.editor) {
 						activeEditor = snapshot.id;
 					}
-				});
+				}
 			}
 		}
 

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

@@ -25,7 +25,7 @@ export class MainThreadFileSystem implements MainThreadFileSystemShape {
 	}
 
 	dispose(): void {
-		this._fileProvider.forEach(value => value.dispose());
+		dispose(this._fileProvider.values());
 		this._fileProvider.clear();
 	}
 

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

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { extHostCustomer } from 'vs/workbench/api/common/extHostCustomers';
+import { ExtHostContext, IExtHostContext, ExtHostExtensionServiceShape } from '../common/extHost.protocol';
+import { IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
+
+@extHostCustomer
+export class MainThreadRemoteConnectionData extends Disposable {
+
+	private readonly _proxy: ExtHostExtensionServiceShape;
+
+	constructor(
+		extHostContext: IExtHostContext,
+		@IWorkbenchEnvironmentService protected readonly _environmentService: IWorkbenchEnvironmentService,
+		@IRemoteAuthorityResolverService remoteAuthorityResolverService: IRemoteAuthorityResolverService
+	) {
+		super();
+		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostExtensionService);
+
+		const remoteAuthority = this._environmentService.configuration.remoteAuthority;
+		if (remoteAuthority) {
+			this._register(remoteAuthorityResolverService.onDidChangeConnectionData(() => {
+				const connectionData = remoteAuthorityResolverService.getConnectionData(remoteAuthority);
+				if (connectionData) {
+					this._proxy.$updateRemoteConnectionData(connectionData);
+				}
+			}));
+		}
+	}
+}

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

@@ -252,7 +252,7 @@ export class MainThreadWebviews extends Disposable implements extHostProtocol.Ma
 
 	public async $postMessage(handle: extHostProtocol.WebviewPanelHandle, message: any): Promise<boolean> {
 		const webview = this.getWebviewInput(handle);
-		webview.webview.sendMessage(message);
+		webview.webview.postMessage(message);
 		return true;
 	}