add new embed API for clearing credentials

Author: TylerLeonhardt

src/vs/code/browser/workbench/workbench.ts

@@ -185,6 +185,10 @@ class LocalStorageCredentialsProvider implements ICredentialsProvider {
 			url: doCreateUri('/auth/logout', queryValues).toString(true)
 		}, CancellationToken.None);
 	}
+
+	async clear(): Promise<void> {
+		window.localStorage.removeItem(LocalStorageCredentialsProvider.CREDENTIALS_OPENED_KEY);
+	}
 }
 
 class PollingURLCallbackProvider extends Disposable implements IURLCallbackProvider {

src/vs/workbench/browser/web.main.ts

@@ -65,6 +65,8 @@ import { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService } fr
 import { HTMLFileSystemProvider } from 'vs/platform/files/browser/htmlFileSystemProvider';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 import { safeStringify } from 'vs/base/common/objects';
+import { ICredentialsService } from 'vs/workbench/services/credentials/common/credentials';
+import { BrowserCredentialsService } from 'vs/workbench/services/credentials/browser/credentialsService';
 
 class BrowserMain extends Disposable {
 
@@ -329,6 +331,7 @@ class BrowserMain extends Disposable {
 				const dialogService = accessor.get(IDialogService);
 				const hostService = accessor.get(IHostService);
 				const storageService = accessor.get(IStorageService);
+				const credentialsService = accessor.get(ICredentialsService);
 				const result = await dialogService.confirm({
 					message: localize('reset user data message', "Would you like to reset your data (settings, keybindings, extensions, snippets and UI State) and reload?")
 				});
@@ -338,6 +341,9 @@ class BrowserMain extends Disposable {
 					if (storageService instanceof BrowserStorageService) {
 						await storageService.clear();
 					}
+					if (credentialsService instanceof BrowserCredentialsService) {
+						await credentialsService.clear();
+					}
 				}
 
 				hostService.reload();

src/vs/workbench/services/credentials/browser/credentialsService.ts

@@ -54,6 +54,12 @@ export class BrowserCredentialsService extends Disposable implements ICredential
 	findCredentials(service: string): Promise<Array<{ account: string, password: string; }>> {
 		return this.credentialsProvider.findCredentials(service);
 	}
+
+	async clear(): Promise<void> {
+		if (this.credentialsProvider.clear) {
+			return this.credentialsProvider.clear();
+		}
+	}
 }
 
 interface ICredential {
@@ -80,7 +86,7 @@ class InMemoryCredentialsProvider implements ICredentialsProvider {
 	async deletePassword(service: string, account: string): Promise<boolean> {
 		const credential = this.doFindPassword(service, account);
 		if (credential) {
-			this.credentials = this.credentials.splice(this.credentials.indexOf(credential), 1);
+			this.credentials.splice(this.credentials.indexOf(credential), 1);
 		}
 
 		return !!credential;
@@ -102,6 +108,10 @@ class InMemoryCredentialsProvider implements ICredentialsProvider {
 			.filter(credential => credential.service === service)
 			.map(({ account, password }) => ({ account, password }));
 	}
+
+	async clear(): Promise<void> {
+		this.credentials = [];
+	}
 }
 
 registerSingleton(ICredentialsService, BrowserCredentialsService, true);

src/vs/workbench/services/credentials/common/credentials.ts

@@ -14,6 +14,7 @@ export interface ICredentialsProvider {
 	deletePassword(service: string, account: string): Promise<boolean>;
 	findPassword(service: string): Promise<string | null>;
 	findCredentials(service: string): Promise<Array<{ account: string, password: string }>>;
+	clear?(): Promise<void>;
 }
 
 export interface ICredentialsChangeEvent {

src/vs/workbench/services/credentials/electron-sandbox/credentialsService.ts

@@ -45,6 +45,10 @@ export class KeytarCredentialsService extends Disposable implements ICredentials
 	findCredentials(service: string): Promise<Array<{ account: string, password: string }>> {
 		return this.nativeHostService.findCredentials(service);
 	}
+
+	// This class doesn't implement the clear() function because we don't know
+	// what services have stored credentials. For reference, a "service" is an extension.
+	// TODO: should we clear credentials for the built-in auth extensions?
 }
 
 registerSingleton(ICredentialsService, KeytarCredentialsService, true);

src/vs/workbench/services/credentials/test/browser/credentialsService.test.ts

@@ -0,0 +1,60 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { BrowserCredentialsService } from 'vs/workbench/services/credentials/browser/credentialsService';
+import { TestEnvironmentService } from 'vs/workbench/test/browser/workbenchTestServices';
+
+suite('CredentialsService - web', () => {
+	const serviceId1 = 'test.credentialsService1';
+	const serviceId2 = 'test.credentialsService2';
+	const disposables = new DisposableStore();
+	let credentialsService: BrowserCredentialsService;
+	setup(async () => {
+		credentialsService = disposables.add(new BrowserCredentialsService(TestEnvironmentService));
+		await credentialsService.setPassword(serviceId1, 'me1', '1');
+		await credentialsService.setPassword(serviceId1, 'me2', '2');
+		await credentialsService.setPassword(serviceId2, 'me3', '3');
+	});
+
+	teardown(() => disposables.clear());
+
+	test('Gets correct values for service', async () => {
+		const credentials = await credentialsService.findCredentials(serviceId1);
+		assert.strictEqual(credentials.length, 2);
+		assert.strictEqual(credentials[0].password, '1');
+	});
+
+	test('Gets correct value for credential', async () => {
+		const credentials = await credentialsService.getPassword(serviceId1, 'me1');
+		assert.strictEqual(credentials, '1');
+	});
+
+	test('Gets null for no account', async () => {
+		const credentials = await credentialsService.getPassword(serviceId1, 'doesnotexist');
+		assert.strictEqual(credentials, null);
+	});
+
+	test('Gets null for no service or a different service', async () => {
+		let credentials = await credentialsService.getPassword('doesnotexist', 'me1');
+		assert.strictEqual(credentials, null);
+		credentials = await credentialsService.getPassword(serviceId2, 'me1');
+		assert.strictEqual(credentials, null);
+	});
+
+	test('Delete removes the value', async () => {
+		const result = await credentialsService.deletePassword(serviceId1, 'me1');
+		assert.strictEqual(result, true);
+		const pass = await credentialsService.getPassword(serviceId1, 'me1');
+		assert.strictEqual(pass, null);
+	});
+
+	test('Clear removes all values for service', async () => {
+		await credentialsService.clear();
+		const credentials = await credentialsService.findCredentials(serviceId1);
+		assert.strictEqual(credentials.length, 0);
+	});
+});