Introduce id and user data sync store registry

src/vs/platform/userDataSync/common/userDataSync.ts

@@ -58,6 +58,7 @@ export class UserDataSyncStoreError extends Error {
 }
 
 export interface IUserDataSyncStore {
+	readonly id: string;
 	readonly name: string;
 	read(key: string): Promise<IUserData | null>;
 	write(key: string, content: string, ref: string | null): Promise<string>;

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

@@ -22,9 +22,10 @@ export class MainThreadUserData extends Disposable implements MainThreadUserData
 		this._register(toDisposable(() => this.userDataSyncStoreService.deregisterUserDataSyncStore()));
 	}
 
-	$registerUserDataProvider(name: string): void {
+	$registerUserDataProvider(id: string, name: string): void {
 		const proxy = this.proxy;
 		this.userDataSyncStoreService.registerUserDataSyncStore({
+			id,
 			name,
 			read(key: string): Promise<IUserData | null> {
 				return proxy.$read(key);

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

@@ -546,9 +546,9 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			createInputBox(): vscode.InputBox {
 				return extHostQuickOpen.createInputBox(extension.identifier);
 			},
-			registerUserDataSyncProvider: (identity: string, userDataProvider: vscode.UserDataSyncProvider): vscode.Disposable => {
+			registerUserDataSyncProvider: (name: string, userDataProvider: vscode.UserDataSyncProvider): vscode.Disposable => {
 				checkProposedApiEnabled(extension);
-				return extHostUserData.registerUserDataProvider(identity, userDataProvider);
+				return extHostUserData.registerUserDataProvider(extension.identifier.value, name, userDataProvider);
 			}
 		};
 

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

@@ -147,7 +147,7 @@ export interface MainThreadConfigurationShape extends IDisposable {
 }
 
 export interface MainThreadUserDataShape extends IDisposable {
-	$registerUserDataProvider(name: string): void;
+	$registerUserDataProvider(id: string, name: string): void;
 	$deregisterUserDataProvider(): void;
 }
 

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

@@ -20,14 +20,14 @@ export class ExtHostUserData implements ExtHostUserDataShape {
 	) {
 	}
 
-	registerUserDataProvider(name: string, userDataProvider: vscode.UserDataSyncProvider): vscode.Disposable {
+	registerUserDataProvider(id: string, name: string, userDataProvider: vscode.UserDataSyncProvider): vscode.Disposable {
 		if (this.userDataProvider) {
 			this.logService.warn(`A user data provider '${this.name}' already exists hence ignoring the remote user data provider '${name}'.`);
 			return Disposable.None;
 		}
 		this.userDataProvider = userDataProvider;
 		this.name = name;
-		this.proxy.$registerUserDataProvider(name);
+		this.proxy.$registerUserDataProvider(id, name);
 		return toDisposable(() => this.proxy.$deregisterUserDataProvider());
 	}
 

src/vs/workbench/services/userDataSync/common/userDataSyncStores.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Event, Emitter } from 'vs/base/common/event';
+import { IUserDataSyncStore } from 'vs/platform/userDataSync/common/userDataSync';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { values } from 'vs/base/common/map';
+import { Registry } from 'vs/platform/registry/common/platform';
+
+
+export namespace Extensions {
+	export const UserDataSyncStoresRegistry = 'workbench.registry.userData.syncStores';
+}
+
+export interface IUserDataSyncStoresRegistry {
+	/**
+	 * An event that is triggerred when a user data sync store is registered.
+	 */
+	readonly onDidRegister: Event<IUserDataSyncStore>;
+
+	/**
+	 * An event that is triggerred when a user data sync store is deregistered.
+	 */
+	readonly onDidDeregister: Event<string>;
+
+	/**
+	 * All registered user data sync stores
+	 */
+	readonly all: IUserDataSyncStore[];
+
+	/**
+	 * Registers a user data sync store
+	 *
+	 * @param userDataSyncStore to register
+	 */
+	registerUserDataSyncStore(userDataSyncStore: IUserDataSyncStore): void;
+
+	/**
+	 * Deregisters the user data sync store with given id
+	 */
+	deregisterUserDataSyncStore(id: string): void;
+
+	/**
+	 * Returns the user data sync store with given id.
+	 *
+	 * @returns the user data sync store with given id.
+	 */
+	get(id: string): IUserDataSyncStore | undefined;
+}
+
+class UserDataSyncStoresRegistryImpl extends Disposable implements IUserDataSyncStoresRegistry {
+
+	private readonly _onDidRegister = this._register(new Emitter<IUserDataSyncStore>());
+	readonly onDidRegister: Event<IUserDataSyncStore> = this._onDidRegister.event;
+
+	private readonly _onDidDeregister = this._register(new Emitter<string>());
+	readonly onDidDeregister: Event<string> = this._onDidDeregister.event;
+
+	private userDataSyncStores: Map<string, IUserDataSyncStore> = new Map<string, IUserDataSyncStore>();
+
+	get all(): IUserDataSyncStore[] {
+		return values(this.userDataSyncStores);
+	}
+
+	registerUserDataSyncStore(userDataSyncStore: IUserDataSyncStore): void {
+		const existing = this.userDataSyncStores.get(userDataSyncStore.id);
+		if (existing) {
+			return;
+		}
+
+		this.userDataSyncStores.set(userDataSyncStore.id, userDataSyncStore);
+		this._onDidRegister.fire(userDataSyncStore);
+	}
+
+	deregisterUserDataSyncStore(id: string): void {
+		const existing = this.userDataSyncStores.get(id);
+		if (existing) {
+			this.userDataSyncStores.delete(id);
+			this._onDidDeregister.fire(id);
+		}
+	}
+
+	get(id: string): IUserDataSyncStore | undefined {
+		return this.userDataSyncStores.get(id);
+	}
+}
+
+Registry.add(Extensions.UserDataSyncStoresRegistry, new UserDataSyncStoresRegistryImpl());