Merge pull request microsoft#154756 from microsoft/sandy081/profiles-enable-web

Enable profiles in Web

Author: sandy081

src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts

@@ -232,7 +232,7 @@ class SharedProcessMain extends Disposable {
 		fileService.registerProvider(Schemas.vscodeUserData, userDataFileSystemProvider);
 
 		// User Data Profiles
-		const userDataProfilesService = this._register(new UserDataProfilesNativeService(this.configuration.profiles, mainProcessService, environmentService, fileService, logService));
+		const userDataProfilesService = this._register(new UserDataProfilesNativeService(this.configuration.profiles, mainProcessService, environmentService));
 		services.set(IUserDataProfilesService, userDataProfilesService);
 
 		// Configuration

src/vs/platform/extensionManagement/test/node/extensionsScannerService.test.ts

@@ -18,6 +18,7 @@ import { IInstantiationService } from 'vs/platform/instantiation/common/instanti
 import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
 import { ILogService, NullLogService } from 'vs/platform/log/common/log';
 import { IProductService } from 'vs/platform/product/common/productService';
+import { UriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentityService';
 import { IUserDataProfilesService, UserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
 
 let translations: Translations = Object.create(null);
@@ -72,7 +73,7 @@ suite('NativeExtensionsScanerService Test', () => {
 		});
 		instantiationService.stub(IProductService, { version: '1.66.0' });
 		instantiationService.stub(IExtensionsProfileScannerService, new ExtensionsProfileScannerService(fileService, logService));
-		instantiationService.stub(IUserDataProfilesService, new UserDataProfilesService(environmentService, fileService, logService));
+		instantiationService.stub(IUserDataProfilesService, new UserDataProfilesService(environmentService, fileService, new UriIdentityService(fileService), logService));
 		await fileService.createFolder(systemExtensionsLocation);
 		await fileService.createFolder(userExtensionsLocation);
 	});

src/vs/platform/userData/test/browser/fileUserDataProvider.test.ts

@@ -19,6 +19,7 @@ import { AbstractNativeEnvironmentService } from 'vs/platform/environment/common
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import product from 'vs/platform/product/common/product';
 import { IUserDataProfilesService, UserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
+import { UriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentityService';
 
 const ROOT = URI.file('tests').with({ scheme: 'vscode-tests' });
 
@@ -52,7 +53,7 @@ suite('FileUserDataProvider', () => {
 		await testObject.createFolder(backupWorkspaceHomeOnDisk);
 
 		environmentService = new TestEnvironmentService(userDataHomeOnDisk);
-		userDataProfilesService = new UserDataProfilesService(environmentService, testObject, logService);
+		userDataProfilesService = new UserDataProfilesService(environmentService, testObject, new UriIdentityService(testObject), logService);
 
 		fileUserDataProvider = new FileUserDataProvider(ROOT.scheme, fileSystemProvider, Schemas.vscodeUserData, logService);
 		disposables.add(fileUserDataProvider);

src/vs/platform/userDataProfile/browser/userDataProfile.ts

@@ -3,20 +3,64 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { revive } from 'vs/base/common/marshalling';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { IFileService } from 'vs/platform/files/common/files';
 import { ILogService } from 'vs/platform/log/common/log';
-import { IUserDataProfilesService, UserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
+import { IUriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentity';
+import { IUserDataProfilesService, PROFILES_ENABLEMENT_CONFIG, StoredProfileAssociations, StoredUserDataProfile, UserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
 
 export class BrowserUserDataProfilesService extends UserDataProfilesService implements IUserDataProfilesService {
 
+	protected override readonly defaultProfileShouldIncludeExtensionsResourceAlways: boolean = true;
+
 	constructor(
 		@IEnvironmentService environmentService: IEnvironmentService,
 		@IFileService fileService: IFileService,
+		@IUriIdentityService uriIdentityService: IUriIdentityService,
 		@ILogService logService: ILogService,
 	) {
-		super(environmentService, fileService, logService);
-		this._profiles = [this.createDefaultUserDataProfile(true)];
+		super(environmentService, fileService, uriIdentityService, logService);
+		super.setEnablement(window.localStorage.getItem(PROFILES_ENABLEMENT_CONFIG) === 'true');
+	}
+
+	override setEnablement(enabled: boolean): void {
+		super.setEnablement(enabled);
+		window.localStorage.setItem(PROFILES_ENABLEMENT_CONFIG, enabled ? 'true' : 'false');
+	}
+
+	protected override getStoredProfiles(): StoredUserDataProfile[] {
+		try {
+			const value = window.localStorage.getItem(UserDataProfilesService.PROFILES_KEY);
+			if (value) {
+				return revive(JSON.parse(value));
+			}
+		} catch (error) {
+			/* ignore */
+			this.logService.error(error);
+		}
+		return [];
+	}
+
+	protected override saveStoredProfiles(storedProfiles: StoredUserDataProfile[]): void {
+		window.localStorage.setItem(UserDataProfilesService.PROFILES_KEY, JSON.stringify(storedProfiles));
+	}
+
+	protected override getStoredProfileAssociations(): StoredProfileAssociations {
+		try {
+			const value = window.localStorage.getItem(UserDataProfilesService.PROFILE_ASSOCIATIONS_KEY);
+			if (value) {
+				return revive(JSON.parse(value));
+			}
+		} catch (error) {
+			/* ignore */
+			this.logService.error(error);
+		}
+		return {};
+	}
+
+	protected override saveStoredProfileAssociations(storedProfileAssociations: StoredProfileAssociations): void {
+		window.localStorage.setItem(UserDataProfilesService.PROFILE_ASSOCIATIONS_KEY, JSON.stringify(storedProfileAssociations));
 	}
 
 }

src/vs/platform/userDataProfile/common/userDataProfile.ts

@@ -14,7 +14,11 @@ import { IEnvironmentService } from 'vs/platform/environment/common/environment'
 import { IFileService } from 'vs/platform/files/common/files';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { ILogService } from 'vs/platform/log/common/log';
-import { ISingleFolderWorkspaceIdentifier, IWorkspaceIdentifier } from 'vs/platform/workspace/common/workspace';
+import { ISingleFolderWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier, IWorkspaceIdentifier } from 'vs/platform/workspace/common/workspace';
+import { ResourceMap } from 'vs/base/common/map';
+import { IStringDictionary } from 'vs/base/common/collections';
+import { IUriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentity';
+import { Promises } from 'vs/base/common/async';
 
 /**
  * Flags to indicate whether to use the default profile or not.
@@ -66,6 +70,16 @@ export type WorkspaceIdentifier = ISingleFolderWorkspaceIdentifier | IWorkspaceI
 
 export type DidChangeProfilesEvent = { readonly added: IUserDataProfile[]; readonly removed: IUserDataProfile[]; readonly all: IUserDataProfile[] };
 
+export type WillCreateProfileEvent = {
+	profile: IUserDataProfile;
+	join(promise: Promise<void>): void;
+};
+
+export type WillRemoveProfileEvent = {
+	profile: IUserDataProfile;
+	join(promise: Promise<void>): void;
+};
+
 export const IUserDataProfilesService = createDecorator<IUserDataProfilesService>('IUserDataProfilesService');
 export interface IUserDataProfilesService {
 	readonly _serviceBrand: undefined;
@@ -115,34 +129,249 @@ export function toUserDataProfile(name: string, location: URI, useDefaultFlags?:
 	};
 }
 
+export type UserDataProfilesObject = {
+	profiles: IUserDataProfile[];
+	workspaces: ResourceMap<IUserDataProfile>;
+	emptyWindow?: IUserDataProfile;
+};
+
+export type StoredUserDataProfile = {
+	name: string;
+	location: URI;
+	useDefaultFlags?: UseDefaultProfileFlags;
+};
+
+export type StoredProfileAssociations = {
+	workspaces?: IStringDictionary<string>;
+	emptyWindow?: string;
+};
+
 export class UserDataProfilesService extends Disposable implements IUserDataProfilesService {
+
+	protected static readonly PROFILES_KEY = 'userDataProfiles';
+	protected static readonly PROFILE_ASSOCIATIONS_KEY = 'profileAssociations';
+
 	readonly _serviceBrand: undefined;
 
+	private enabled: boolean = false;
+	protected readonly defaultProfileShouldIncludeExtensionsResourceAlways: boolean = false;
 	readonly profilesHome: URI;
 
 	get defaultProfile(): IUserDataProfile { return this.profiles[0]; }
-	protected _profiles: IUserDataProfile[] = [this.createDefaultUserDataProfile(false)];
-	get profiles(): IUserDataProfile[] { return this._profiles; }
+	get profiles(): IUserDataProfile[] { return this.profilesObject.profiles; }
 
 	protected readonly _onDidChangeProfiles = this._register(new Emitter<DidChangeProfilesEvent>());
 	readonly onDidChangeProfiles = this._onDidChangeProfiles.event;
 
+	protected readonly _onWillCreateProfile = this._register(new Emitter<WillCreateProfileEvent>());
+	readonly onWillCreateProfile = this._onWillCreateProfile.event;
+
+	protected readonly _onWillRemoveProfile = this._register(new Emitter<WillRemoveProfileEvent>());
+	readonly onWillRemoveProfile = this._onWillRemoveProfile.event;
+
 	constructor(
 		@IEnvironmentService protected readonly environmentService: IEnvironmentService,
 		@IFileService protected readonly fileService: IFileService,
+		@IUriIdentityService protected readonly uriIdentityService: IUriIdentityService,
 		@ILogService protected readonly logService: ILogService
 	) {
 		super();
 		this.profilesHome = joinPath(this.environmentService.userRoamingDataHome, 'profiles');
 	}
 
-	protected createDefaultUserDataProfile(extensions: boolean): IUserDataProfile {
-		const profile = toUserDataProfile(localize('defaultProfile', "Default"), this.environmentService.userRoamingDataHome);
-		return { ...profile, isDefault: true, extensionsResource: extensions ? profile.extensionsResource : undefined };
+	setEnablement(enabled: boolean): void {
+		if (this.enabled !== enabled) {
+			this._profilesObject = undefined;
+			this.enabled = enabled;
+		}
+	}
+
+	protected _profilesObject: UserDataProfilesObject | undefined;
+	protected get profilesObject(): UserDataProfilesObject {
+		if (!this._profilesObject) {
+			const profiles = this.enabled ? this.getStoredProfiles().map<IUserDataProfile>(storedProfile => toUserDataProfile(storedProfile.name, storedProfile.location, storedProfile.useDefaultFlags)) : [];
+			let emptyWindow: IUserDataProfile | undefined;
+			const workspaces = new ResourceMap<IUserDataProfile>();
+			if (profiles.length) {
+				const profileAssicaitions = this.getStoredProfileAssociations();
+				if (profileAssicaitions.workspaces) {
+					for (const [workspacePath, profilePath] of Object.entries(profileAssicaitions.workspaces)) {
+						const workspace = URI.parse(workspacePath);
+						const profileLocation = URI.parse(profilePath);
+						const profile = profiles.find(p => this.uriIdentityService.extUri.isEqual(p.location, profileLocation));
+						if (profile) {
+							workspaces.set(workspace, profile);
+						}
+					}
+				}
+				if (profileAssicaitions.emptyWindow) {
+					const emptyWindowProfileLocation = URI.parse(profileAssicaitions.emptyWindow);
+					emptyWindow = profiles.find(p => this.uriIdentityService.extUri.isEqual(p.location, emptyWindowProfileLocation));
+				}
+			}
+			const profile = toUserDataProfile(localize('defaultProfile', "Default"), this.environmentService.userRoamingDataHome);
+			profiles.unshift({ ...profile, isDefault: true, extensionsResource: this.defaultProfileShouldIncludeExtensionsResourceAlways || profiles.length > 0 ? profile.extensionsResource : undefined });
+			this._profilesObject = { profiles, workspaces, emptyWindow };
+		}
+		return this._profilesObject;
+	}
+
+	getProfile(workspaceIdentifier: WorkspaceIdentifier): IUserDataProfile {
+		const workspace = this.getWorkspace(workspaceIdentifier);
+		const profile = URI.isUri(workspace) ? this.profilesObject.workspaces.get(workspace) : this.profilesObject.emptyWindow;
+		return profile ?? this.defaultProfile;
+	}
+
+	protected getWorkspace(workspaceIdentifier: WorkspaceIdentifier): URI | EmptyWindowWorkspaceIdentifier {
+		if (isSingleFolderWorkspaceIdentifier(workspaceIdentifier)) {
+			return workspaceIdentifier.uri;
+		}
+		if (isWorkspaceIdentifier(workspaceIdentifier)) {
+			return workspaceIdentifier.configPath;
+		}
+		return 'empty-window';
+	}
+
+	async createProfile(name: string, useDefaultFlags?: UseDefaultProfileFlags, workspaceIdentifier?: WorkspaceIdentifier): Promise<IUserDataProfile> {
+		if (!this.enabled) {
+			throw new Error(`Settings Profiles are disabled. Enable them via the '${PROFILES_ENABLEMENT_CONFIG}' setting.`);
+		}
+		if (this.getStoredProfiles().some(p => p.name === name)) {
+			throw new Error(`Profile with name ${name} already exists`);
+		}
+
+		const profile = toUserDataProfile(name, joinPath(this.profilesHome, hash(name).toString(16)), useDefaultFlags);
+		await this.fileService.createFolder(profile.location);
+
+		const joiners: Promise<void>[] = [];
+		this._onWillCreateProfile.fire({
+			profile,
+			join(promise) {
+				joiners.push(promise);
+			}
+		});
+		await Promises.settled(joiners);
+
+		this.updateProfiles([profile], []);
+
+		if (workspaceIdentifier) {
+			await this.setProfileForWorkspace(profile, workspaceIdentifier);
+		}
+
+		return profile;
+	}
+
+	async setProfileForWorkspace(profileToSet: IUserDataProfile, workspaceIdentifier: WorkspaceIdentifier): Promise<void> {
+		if (!this.enabled) {
+			throw new Error(`Settings Profiles are disabled. Enable them via the '${PROFILES_ENABLEMENT_CONFIG}' setting.`);
+		}
+
+		const profile = this.profiles.find(p => p.id === profileToSet.id);
+		if (!profile) {
+			throw new Error(`Profile '${profileToSet.name}' does not exist`);
+		}
+
+		this.updateWorkspaceAssociation(workspaceIdentifier, profile);
+	}
+
+	async unsetWorkspace(workspaceIdentifier: WorkspaceIdentifier): Promise<void> {
+		if (!this.enabled) {
+			throw new Error(`Settings Profiles are disabled. Enable them via the '${PROFILES_ENABLEMENT_CONFIG}' setting.`);
+		}
+		this.updateWorkspaceAssociation(workspaceIdentifier);
+	}
+
+	async removeProfile(profileToRemove: IUserDataProfile): Promise<void> {
+		if (!this.enabled) {
+			throw new Error(`Settings Profiles are disabled. Enable them via the '${PROFILES_ENABLEMENT_CONFIG}' setting.`);
+		}
+		if (profileToRemove.isDefault) {
+			throw new Error('Cannot remove default profile');
+		}
+		const profile = this.profiles.find(p => p.id === profileToRemove.id);
+		if (!profile) {
+			throw new Error(`Profile '${profileToRemove.name}' does not exist`);
+		}
+
+		const joiners: Promise<void>[] = [];
+		this._onWillRemoveProfile.fire({
+			profile,
+			join(promise) {
+				joiners.push(promise);
+			}
+		});
+		await Promises.settled(joiners);
+
+		if (profile.id === this.profilesObject.emptyWindow?.id) {
+			this.profilesObject.emptyWindow = undefined;
+		}
+		for (const workspace of [...this.profilesObject.workspaces.keys()]) {
+			if (profile.id === this.profilesObject.workspaces.get(workspace)?.id) {
+				this.profilesObject.workspaces.delete(workspace);
+			}
+		}
+		this.updateStoredProfileAssociations();
+
+		this.updateProfiles([], [profile]);
+
+		try {
+			if (this.profiles.length === 1) {
+				await this.fileService.del(this.profilesHome, { recursive: true });
+			} else {
+				await this.fileService.del(profile.location, { recursive: true });
+			}
+		} catch (error) {
+			this.logService.error(error);
+		}
+	}
+
+	private updateProfiles(added: IUserDataProfile[], removed: IUserDataProfile[]) {
+		const storedProfiles: StoredUserDataProfile[] = [];
+		for (const profile of [...this.profilesObject.profiles, ...added]) {
+			if (profile.isDefault) {
+				continue;
+			}
+			if (removed.some(p => profile.id === p.id)) {
+				continue;
+			}
+			storedProfiles.push({ location: profile.location, name: profile.name, useDefaultFlags: profile.useDefaultFlags });
+		}
+		this.saveStoredProfiles(storedProfiles);
+		this._profilesObject = undefined;
+		this._onDidChangeProfiles.fire({ added, removed, all: this.profiles });
+	}
+
+	private updateWorkspaceAssociation(workspaceIdentifier: WorkspaceIdentifier, newProfile?: IUserDataProfile) {
+		const workspace = this.getWorkspace(workspaceIdentifier);
+
+		// Folder or Multiroot workspace
+		if (URI.isUri(workspace)) {
+			this.profilesObject.workspaces.delete(workspace);
+			if (newProfile && !newProfile.isDefault) {
+				this.profilesObject.workspaces.set(workspace, newProfile);
+			}
+		}
+		// Empty Window
+		else {
+			this.profilesObject.emptyWindow = !newProfile?.isDefault ? newProfile : undefined;
+		}
+
+		this.updateStoredProfileAssociations();
+	}
+
+	private updateStoredProfileAssociations() {
+		const workspaces: IStringDictionary<string> = {};
+		for (const [workspace, profile] of this.profilesObject.workspaces.entries()) {
+			workspaces[workspace.toString()] = profile.location.toString();
+		}
+		const emptyWindow = this.profilesObject.emptyWindow?.location.toString();
+		this.saveStoredProfileAssociations({ workspaces, emptyWindow });
+		this._profilesObject = undefined;
 	}
 
-	createProfile(name: string, useDefaultFlags?: UseDefaultProfileFlags, workspaceIdentifier?: WorkspaceIdentifier): Promise<IUserDataProfile> { throw new Error('Not implemented'); }
-	setProfileForWorkspace(profile: IUserDataProfile, workspaceIdentifier: WorkspaceIdentifier): Promise<void> { throw new Error('Not implemented'); }
-	getProfile(workspaceIdentifier: WorkspaceIdentifier): IUserDataProfile { throw new Error('Not implemented'); }
-	removeProfile(profile: IUserDataProfile): Promise<void> { throw new Error('Not implemented'); }
+	protected getStoredProfiles(): StoredUserDataProfile[] { return []; }
+	protected saveStoredProfiles(storedProfiles: StoredUserDataProfile[]): void { throw new Error('not implemented'); }
+
+	protected getStoredProfileAssociations(): StoredProfileAssociations { return {}; }
+	protected saveStoredProfileAssociations(storedProfileAssociations: StoredProfileAssociations): void { throw new Error('not implemented'); }
 }