add apis to storage keys registry service to register extension storage keys

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

@@ -5,6 +5,7 @@
 
 import { Event, Emitter } from 'vs/base/common/event';
 import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { IExtensionIdentifierWithVersion } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 
 export interface IStorageKey {
@@ -14,6 +15,28 @@ export interface IStorageKey {
 
 }
 
+export interface IExtensionIdWithVersion {
+	id: string;
+	version: string;
+}
+
+export namespace ExtensionIdWithVersion {
+
+	const EXTENSION_ID_VERSION_REGEX = /^([^.]+\..+)@(\d+\.\d+\.\d+(-.*)?)$/;
+
+	export function toKey(extension: IExtensionIdWithVersion): string {
+		return `${extension.id}@${extension.version}`;
+	}
+
+	export function fromKey(key: string): IExtensionIdWithVersion | undefined {
+		const matches = EXTENSION_ID_VERSION_REGEX.exec(key);
+		if (matches && matches[1]) {
+			return { id: matches[1], version: matches[2] };
+		}
+		return undefined;
+	}
+}
+
 export const IStorageKeysSyncRegistryService = createDecorator<IStorageKeysSyncRegistryService>('IStorageKeysSyncRegistryService');
 
 export interface IStorageKeysSyncRegistryService {
@@ -35,23 +58,68 @@ export interface IStorageKeysSyncRegistryService {
 	 */
 	registerStorageKey(key: IStorageKey): void;
 
+	/**
+	 * All registered extensions storage keys
+	 */
+	readonly extensionsStorageKeys: ReadonlyArray<[IExtensionIdentifierWithVersion, ReadonlyArray<string>]>;
+
+	/**
+	 * Event that is triggered when extension storage keys are changed
+	 */
+	onDidChangeExtensionStorageKeys: Event<[IExtensionIdWithVersion, ReadonlyArray<string>]>;
+
+	/**
+	 * Register storage keys that has to be synchronized for the given extension.
+	 */
+	registerExtensionStorageKeys(extension: IExtensionIdWithVersion, keys: string[]): void;
+
+	/**
+	 * Returns storage keys of the given extension that has to be synchronized.
+	 */
+	getExtensioStorageKeys(extension: IExtensionIdWithVersion): ReadonlyArray<string>;
 }
 
-export class StorageKeysSyncRegistryService extends Disposable implements IStorageKeysSyncRegistryService {
+export abstract class AbstractStorageKeysSyncRegistryService extends Disposable implements IStorageKeysSyncRegistryService {
 
-	_serviceBrand: any;
+	declare readonly _serviceBrand: undefined;
 
-	private readonly _storageKeys = new Map<string, IStorageKey>();
+	protected readonly _storageKeys = new Map<string, IStorageKey>();
 	get storageKeys(): ReadonlyArray<IStorageKey> { return [...this._storageKeys.values()]; }
 
-	private readonly _onDidChangeStorageKeys: Emitter<ReadonlyArray<IStorageKey>> = this._register(new Emitter<ReadonlyArray<IStorageKey>>());
+	protected readonly _onDidChangeStorageKeys: Emitter<ReadonlyArray<IStorageKey>> = this._register(new Emitter<ReadonlyArray<IStorageKey>>());
 	readonly onDidChangeStorageKeys = this._onDidChangeStorageKeys.event;
 
+	protected readonly _extensionsStorageKeys = new Map<string, string[]>();
+	get extensionsStorageKeys() {
+		const result: [IExtensionIdWithVersion, ReadonlyArray<string>][] = [];
+		this._extensionsStorageKeys.forEach((keys, extension) => result.push([ExtensionIdWithVersion.fromKey(extension)!, keys]));
+		return result;
+	}
+	protected readonly _onDidChangeExtensionStorageKeys = this._register(new Emitter<[IExtensionIdWithVersion, ReadonlyArray<string>]>());
+	readonly onDidChangeExtensionStorageKeys = this._onDidChangeExtensionStorageKeys.event;
+
 	constructor() {
 		super();
 		this._register(toDisposable(() => this._storageKeys.clear()));
 	}
 
+	getExtensioStorageKeys(extension: IExtensionIdWithVersion): ReadonlyArray<string> {
+		return this._extensionsStorageKeys.get(ExtensionIdWithVersion.toKey(extension)) || [];
+	}
+
+	protected updateExtensionStorageKeys(extension: IExtensionIdWithVersion, keys: string[]): void {
+		this._extensionsStorageKeys.set(ExtensionIdWithVersion.toKey(extension), keys);
+		this._onDidChangeExtensionStorageKeys.fire([extension, keys]);
+	}
+
+	abstract registerStorageKey(key: IStorageKey): void;
+	abstract registerExtensionStorageKeys(extension: IExtensionIdWithVersion, keys: string[]): void;
+}
+
+export class StorageKeysSyncRegistryService extends AbstractStorageKeysSyncRegistryService {
+
+	_serviceBrand: any;
+
 	registerStorageKey(storageKey: IStorageKey): void {
 		if (!this._storageKeys.has(storageKey.key)) {
 			this._storageKeys.set(storageKey.key, storageKey);
@@ -59,4 +127,8 @@ export class StorageKeysSyncRegistryService extends Disposable implements IStora
 		}
 	}
 
+	registerExtensionStorageKeys(extension: IExtensionIdWithVersion, keys: string[]): void {
+		this.updateExtensionStorageKeys(extension, keys);
+	}
+
 }

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

@@ -4,16 +4,16 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IServerChannel, IChannel, IPCServer } from 'vs/base/parts/ipc/common/ipc';
-import { Event, Emitter } from 'vs/base/common/event';
+import { Event } from 'vs/base/common/event';
 import { IUserDataSyncService, IUserDataSyncUtilService, IUserDataAutoSyncService, IManualSyncTask, IUserDataManifest, IUserDataSyncStoreManagementService, SyncStatus } from 'vs/platform/userDataSync/common/userDataSync';
 import { URI } from 'vs/base/common/uri';
 import { IStringDictionary } from 'vs/base/common/collections';
 import { FormattingOptions } from 'vs/base/common/jsonFormatter';
-import { IStorageKeysSyncRegistryService, IStorageKey } from 'vs/platform/userDataSync/common/storageKeys';
-import { Disposable } from 'vs/base/common/lifecycle';
+import { IStorageKeysSyncRegistryService, IStorageKey, IExtensionIdWithVersion, AbstractStorageKeysSyncRegistryService } from 'vs/platform/userDataSync/common/storageKeys';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IUserDataSyncMachinesService } from 'vs/platform/userDataSync/common/userDataSyncMachines';
 import { IUserDataSyncAccountService } from 'vs/platform/userDataSync/common/userDataSyncAccount';
+import { IExtensionIdentifierWithVersion } from 'vs/platform/extensionManagement/common/extensionManagement';
 
 export class UserDataSyncChannel implements IServerChannel {
 
@@ -175,6 +175,8 @@ export class UserDataSyncUtilServiceClient implements IUserDataSyncUtilService {
 
 }
 
+type StorageKeysSyncRegistryServiceInitData = { storageKeys: ReadonlyArray<IStorageKey>, extensionsStorageKeys: ReadonlyArray<[IExtensionIdWithVersion, ReadonlyArray<string>]> };
+
 export class StorageKeysSyncRegistryChannel implements IServerChannel {
 
 	constructor(private readonly service: IStorageKeysSyncRegistryService) { }
@@ -188,39 +190,49 @@ export class StorageKeysSyncRegistryChannel implements IServerChannel {
 
 	call(context: any, command: string, args?: any): Promise<any> {
 		switch (command) {
-			case '_getInitialData': return Promise.resolve(this.service.storageKeys);
+			case '_getInitialData': return Promise.resolve<StorageKeysSyncRegistryServiceInitData>({ storageKeys: this.service.storageKeys, extensionsStorageKeys: this.service.extensionsStorageKeys });
 			case 'registerStorageKey': return Promise.resolve(this.service.registerStorageKey(args[0]));
 		}
 		throw new Error('Invalid call');
 	}
 }
 
-export class StorageKeysSyncRegistryChannelClient extends Disposable implements IStorageKeysSyncRegistryService {
+export class StorageKeysSyncRegistryChannelClient extends AbstractStorageKeysSyncRegistryService {
 
 	declare readonly _serviceBrand: undefined;
 
-	private _storageKeys: ReadonlyArray<IStorageKey> = [];
-	get storageKeys(): ReadonlyArray<IStorageKey> { return this._storageKeys; }
-	private readonly _onDidChangeStorageKeys: Emitter<ReadonlyArray<IStorageKey>> = this._register(new Emitter<ReadonlyArray<IStorageKey>>());
-	readonly onDidChangeStorageKeys = this._onDidChangeStorageKeys.event;
-
 	constructor(private readonly channel: IChannel) {
 		super();
-		this.channel.call<IStorageKey[]>('_getInitialData').then(storageKeys => {
+		this.channel.call<StorageKeysSyncRegistryServiceInitData>('_getInitialData').then(({ storageKeys, extensionsStorageKeys }) => {
 			this.updateStorageKeys(storageKeys);
+			this.updateExtensionsStorageKeys(extensionsStorageKeys);
 			this._register(this.channel.listen<ReadonlyArray<IStorageKey>>('onDidChangeStorageKeys')(storageKeys => this.updateStorageKeys(storageKeys)));
+			this._register(this.channel.listen<[IExtensionIdentifierWithVersion, string[]]>('onDidChangeExtensionStorageKeys')(e => this.updateExtensionStorageKeys(e[0], e[1])));
 		});
 	}
 
 	private async updateStorageKeys(storageKeys: ReadonlyArray<IStorageKey>): Promise<void> {
-		this._storageKeys = storageKeys;
+		this._storageKeys.clear();
+		for (const storageKey of storageKeys) {
+			this._storageKeys.set(storageKey.key, storageKey);
+		}
 		this._onDidChangeStorageKeys.fire(this.storageKeys);
 	}
 
+	private async updateExtensionsStorageKeys(extensionStorageKeys: ReadonlyArray<[IExtensionIdentifierWithVersion, ReadonlyArray<string>]>): Promise<void> {
+		for (const [extension, keys] of extensionStorageKeys) {
+			this.updateExtensionStorageKeys(extension, [...keys]);
+		}
+	}
+
 	registerStorageKey(storageKey: IStorageKey): void {
 		this.channel.call('registerStorageKey', [storageKey]);
 	}
 
+	registerExtensionStorageKeys(extension: IExtensionIdentifierWithVersion, keys: string[]): void {
+		this.channel.call('registerExtensionStorageKeys', [extension, keys]);
+	}
+
 }
 
 export class UserDataSyncMachinesServiceChannel implements IServerChannel {

src/vs/workbench/electron-sandbox/sandbox.simpleservices.ts

@@ -726,6 +726,14 @@ class SimpleIStorageKeysSyncRegistryService implements IStorageKeysSyncRegistryS
 	storageKeys = [];
 
 	registerStorageKey(): void { }
+
+	onDidChangeExtensionStorageKeys = Event.None;
+
+	extensionsStorageKeys = [];
+
+	getExtensioStorageKeys(): [] { return []; }
+
+	registerExtensionStorageKeys(): void { }
 }
 
 registerSingleton(IStorageKeysSyncRegistryService, SimpleIStorageKeysSyncRegistryService);