Update UX

src/vs/editor/browser/services/openerService.ts

@@ -18,6 +18,7 @@ import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
 import { localize } from 'vs/nls';
 import { IProductService } from 'vs/platform/product/common/product';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import Severity from 'vs/base/common/severity';
 
 export class OpenerService implements IOpenerService {
 
@@ -76,31 +77,34 @@ export class OpenerService implements IOpenerService {
 			if (isDomainTrusted(domainToOpen, trustedDomains)) {
 				return this.openExternal(resource);
 			} else {
-				return this._dialogService.confirm({
-					title: localize('openExternalLink', 'Open External Link'),
-					type: 'question',
-					message: localize(
+				return this._dialogService.show(
+					Severity.Info,
+					localize(
 						'openExternalLinkAt',
 						'Do you want {0} to open the external website?\n{1}',
 						this._productService.productConfiguration.nameShort,
 						resource.toString(true)
 					),
-					primaryButton: localize('openLink', 'Open Link'),
-					secondaryButton: localize('cancel', 'Cancel'),
-					checkbox: {
-						label: localize('trustAllLinksFrom', 'Trust all links from') + ` ${domainToOpen}`,
-						checked: false
-					}
-				}).then(({ confirmed, checkboxChecked }) => {
-					if (checkboxChecked) {
-						this._storageService.store('http.trustedDomains', JSON.stringify([...trustedDomains, domainToOpen]), StorageScope.GLOBAL);
-					}
-					if (confirmed) {
-						return this.openExternal(resource);
-					}
-
-					return Promise.resolve(false);
-				});
+					[
+						localize('openLink', 'Open Link'),
+						localize('cancel', 'Cancel'),
+						localize('configureLinkPermission', 'Configure Link Permission'),
+					],
+					{
+						cancelId: 1
+					}).then((choice) => {
+						if (choice === 0) {
+							return this.openExternal(resource);
+						} else if (choice === 2) {
+							return this._commandService.executeCommand('_workbench.action.configureTrustedDomains', domainToOpen).then((pickedDomains: string[]) => {
+								if (pickedDomains.indexOf(domainToOpen) !== -1) {
+									return this.openExternal(resource);
+								}
+								return Promise.resolve(false);
+							});
+						}
+						return Promise.resolve(false);
+					});
 			}
 		} else if (equalsIgnoreCase(scheme, Schemas.command)) {
 			// run command or bail out if command isn't known

src/vs/workbench/contrib/url/common/url.contribution.ts

@@ -12,6 +12,7 @@ import { IQuickInputService, IQuickPickItem, IQuickPickSeparator } from 'vs/plat
 import { URI } from 'vs/base/common/uri';
 import { Action } from 'vs/base/common/actions';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import { CommandsRegistry } from 'vs/platform/commands/common/commands';
 
 export class OpenUrlAction extends Action {
 
@@ -35,6 +36,70 @@ export class OpenUrlAction extends Action {
 	}
 }
 
+Registry.as<IWorkbenchActionRegistry>(ActionExtensions.WorkbenchActions).registerWorkbenchAction(
+	new SyncActionDescriptor(OpenUrlAction, OpenUrlAction.ID, OpenUrlAction.LABEL),
+	'Open URL',
+	localize('developer', 'Developer')
+);
+
+const configureTrustedDomainsHandler = (
+	quickInputService: IQuickInputService,
+	storageService: IStorageService,
+	domainToConfigure?: string
+) => {
+	let trustedDomains: string[] = [];
+	try {
+		trustedDomains = JSON.parse(storageService.get('http.trustedDomains', StorageScope.GLOBAL, '[]'));
+	} catch (err) { }
+
+	const domainQuickPickItems: IQuickPickItem[] = trustedDomains
+		.filter(d => d !== '*')
+		.map(d => {
+			return {
+				type: 'item',
+				label: d,
+				picked: true,
+			};
+		});
+
+	const specialQuickPickItems: IQuickPickItem[] = [
+		{
+			type: 'item',
+			label: localize('allowAllLinks', 'Allow all links to be open without protection'),
+			picked: trustedDomains.indexOf('*') !== -1
+		}
+	];
+
+	let domainToConfigureItem: IQuickPickItem | undefined = undefined;
+	if (domainToConfigure) {
+		domainToConfigureItem = {
+			type: 'item',
+			label: domainToConfigure,
+			picked: true,
+			description: localize('trustDomainAndOpenLink', 'Trust domain and open link')
+		};
+		specialQuickPickItems.push(<IQuickPickItem>domainToConfigureItem);
+	}
+
+	const quickPickItems: (IQuickPickItem | IQuickPickSeparator)[] = domainQuickPickItems.length === 0
+		? specialQuickPickItems
+		: [...specialQuickPickItems, { type: 'separator' }, ...domainQuickPickItems];
+
+	return quickInputService.pick(quickPickItems, {
+		canPickMany: true,
+		activeItem: domainToConfigureItem
+	}).then(result => {
+		if (result) {
+			const pickedDomains = result.map(r => r.label);
+			storageService.store('http.trustedDomains', JSON.stringify(pickedDomains), StorageScope.GLOBAL);
+
+			return pickedDomains;
+		}
+
+		return [];
+	});
+};
+
 export class ConfigureTrustedDomainsAction extends Action {
 
 	static readonly ID = 'workbench.action.configureTrustedDomains';
@@ -50,45 +115,10 @@ export class ConfigureTrustedDomainsAction extends Action {
 	}
 
 	run(): Promise<any> {
-		let trustedDomains: string[] = [];
-		try {
-			trustedDomains = JSON.parse(this.storageService.get('http.trustedDomains', StorageScope.GLOBAL, '[]'));
-		} catch (err) { }
-
-		const quickPickItems: (IQuickPickItem | IQuickPickSeparator)[] = trustedDomains
-			.filter(d => d !== '*')
-			.map(d => {
-				return {
-					type: 'item',
-					label: d,
-					picked: true,
-				};
-			});
-
-		quickPickItems.unshift({
-			type: 'separator'
-		});
-		quickPickItems.unshift({
-			type: 'item',
-			label: 'Allow all links to be open without protection',
-			picked: trustedDomains.indexOf('*') !== -1
-		});
-
-		return this.quickInputService.pick(quickPickItems, {
-			canPickMany: true
-		}).then(result => {
-			if (result) {
-				this.storageService.store('http.trustedDomains', JSON.stringify(result.map(r => r.label)), StorageScope.GLOBAL);
-			}
-		});
+		return configureTrustedDomainsHandler(this.quickInputService, this.storageService);
 	}
 }
 
-Registry.as<IWorkbenchActionRegistry>(ActionExtensions.WorkbenchActions).registerWorkbenchAction(
-	new SyncActionDescriptor(OpenUrlAction, OpenUrlAction.ID, OpenUrlAction.LABEL),
-	'Open URL',
-	localize('developer', 'Developer')
-);
 Registry.as<IWorkbenchActionRegistry>(ActionExtensions.WorkbenchActions).registerWorkbenchAction(
 	new SyncActionDescriptor(
 		ConfigureTrustedDomainsAction,
@@ -97,3 +127,16 @@ Registry.as<IWorkbenchActionRegistry>(ActionExtensions.WorkbenchActions).registe
 	),
 	'Configure Trusted Domains'
 );
+CommandsRegistry.registerCommand({
+	id: '_workbench.action.configureTrustedDomains',
+	description: {
+		description: 'Configure Trusted Domains',
+		args: [{ name: 'domainToConfigure', schema: { type: 'string' } }]
+	},
+	handler: (accessor, domainToConfigure?: string) => {
+		const quickInputService = accessor.get(IQuickInputService);
+		const storageService = accessor.get(IStorageService);
+
+		return configureTrustedDomainsHandler(quickInputService, storageService, domainToConfigure);
+	}
+});