#86916 introduce global extension enablement service

src/vs/platform/extensionManagement/common/extensionEnablementService.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 { Disposable } from 'vs/base/common/lifecycle';
+import { IExtensionIdentifier, IGlobalExtensionEnablementService, DISABLED_EXTENSIONS_STORAGE_PATH } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { IStorageService, StorageScope, IWorkspaceStorageChangeEvent } from 'vs/platform/storage/common/storage';
+import { isUndefinedOrNull } from 'vs/base/common/types';
+
+export class GlobalExtensionEnablementService extends Disposable implements IGlobalExtensionEnablementService {
+
+	_serviceBrand: undefined;
+
+	private _onDidChangeEnablement = new Emitter<readonly IExtensionIdentifier[]>();
+	readonly onDidChangeEnablement: Event<readonly IExtensionIdentifier[]> = this._onDidChangeEnablement.event;
+	private readonly storageManger: StorageManager;
+
+	constructor(
+		@IStorageService storageService: IStorageService,
+	) {
+		super();
+		this.storageManger = this._register(new StorageManager(storageService));
+		this._register(this.storageManger.onDidChange(extensions => this._onDidChangeEnablement.fire(extensions)));
+	}
+
+	async enableExtension(extension: IExtensionIdentifier): Promise<boolean> {
+		if (this._removeFromDisabledExtensions(extension)) {
+			return true;
+		}
+		return false;
+	}
+
+	async disableExtension(extension: IExtensionIdentifier): Promise<boolean> {
+		if (this._addToDisabledExtensions(extension)) {
+			return true;
+		}
+		return false;
+	}
+
+	getDisabledExtensions(): IExtensionIdentifier[] {
+		return this._getExtensions(DISABLED_EXTENSIONS_STORAGE_PATH);
+	}
+
+	private _addToDisabledExtensions(identifier: IExtensionIdentifier): boolean {
+		let disabledExtensions = this.getDisabledExtensions();
+		if (disabledExtensions.every(e => !areSameExtensions(e, identifier))) {
+			disabledExtensions.push(identifier);
+			this._setDisabledExtensions(disabledExtensions);
+			return true;
+		}
+		return false;
+	}
+
+	private _removeFromDisabledExtensions(identifier: IExtensionIdentifier): boolean {
+		let disabledExtensions = this.getDisabledExtensions();
+		for (let index = 0; index < disabledExtensions.length; index++) {
+			const disabledExtension = disabledExtensions[index];
+			if (areSameExtensions(disabledExtension, identifier)) {
+				disabledExtensions.splice(index, 1);
+				this._setDisabledExtensions(disabledExtensions);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private _setDisabledExtensions(disabledExtensions: IExtensionIdentifier[]): void {
+		this._setExtensions(DISABLED_EXTENSIONS_STORAGE_PATH, disabledExtensions);
+	}
+
+	private _getExtensions(storageId: string): IExtensionIdentifier[] {
+		return this.storageManger.get(storageId, StorageScope.GLOBAL);
+	}
+
+	private _setExtensions(storageId: string, extensions: IExtensionIdentifier[]): void {
+		this.storageManger.set(storageId, extensions, StorageScope.GLOBAL);
+	}
+
+}
+
+export class StorageManager extends Disposable {
+
+	private storage: { [key: string]: string } = Object.create(null);
+
+	private _onDidChange: Emitter<IExtensionIdentifier[]> = this._register(new Emitter<IExtensionIdentifier[]>());
+	readonly onDidChange: Event<IExtensionIdentifier[]> = this._onDidChange.event;
+
+	constructor(private storageService: IStorageService) {
+		super();
+		this._register(storageService.onDidChangeStorage(e => this.onDidStorageChange(e)));
+	}
+
+	get(key: string, scope: StorageScope): IExtensionIdentifier[] {
+		let value: string;
+		if (scope === StorageScope.GLOBAL) {
+			if (isUndefinedOrNull(this.storage[key])) {
+				this.storage[key] = this._get(key, scope);
+			}
+			value = this.storage[key];
+		} else {
+			value = this._get(key, scope);
+		}
+		return JSON.parse(value);
+	}
+
+	set(key: string, value: IExtensionIdentifier[], scope: StorageScope): void {
+		let newValue: string = JSON.stringify(value.map(({ id, uuid }) => (<IExtensionIdentifier>{ id, uuid })));
+		const oldValue = this._get(key, scope);
+		if (oldValue !== newValue) {
+			if (scope === StorageScope.GLOBAL) {
+				if (value.length) {
+					this.storage[key] = newValue;
+				} else {
+					delete this.storage[key];
+				}
+			}
+			this._set(key, value.length ? newValue : undefined, scope);
+		}
+	}
+
+	private onDidStorageChange(workspaceStorageChangeEvent: IWorkspaceStorageChangeEvent): void {
+		if (workspaceStorageChangeEvent.scope === StorageScope.GLOBAL) {
+			if (!isUndefinedOrNull(this.storage[workspaceStorageChangeEvent.key])) {
+				const newValue = this._get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
+				if (newValue !== this.storage[workspaceStorageChangeEvent.key]) {
+					const oldValues = this.get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
+					delete this.storage[workspaceStorageChangeEvent.key];
+					const newValues = this.get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
+					const added = oldValues.filter(oldValue => !newValues.some(newValue => areSameExtensions(oldValue, newValue)));
+					const removed = newValues.filter(newValue => !oldValues.some(oldValue => areSameExtensions(oldValue, newValue)));
+					if (added.length || removed.length) {
+						this._onDidChange.fire([...added, ...removed]);
+					}
+				}
+			}
+		}
+	}
+
+	private _get(key: string, scope: StorageScope): string {
+		return this.storageService.get(key, scope, '[]');
+	}
+
+	private _set(key: string, value: string | undefined, scope: StorageScope): void {
+		if (value) {
+			this.storageService.store(key, value, scope);
+		} else {
+			this.storageService.remove(key, scope);
+		}
+	}
+}

src/vs/platform/extensionManagement/common/extensionManagement.ts

@@ -207,6 +207,18 @@ export interface IExtensionManagementService {
 	updateMetadata(local: ILocalExtension, metadata: IGalleryMetadata): Promise<ILocalExtension>;
 }
 
+export const DISABLED_EXTENSIONS_STORAGE_PATH = 'extensionsIdentifiers/disabled';
+export const ENABLED_EXTENSIONS_STORAGE_PATH = 'extensionsIdentifiers/enabled';
+export const IGlobalExtensionEnablementService = createDecorator<IGlobalExtensionEnablementService>('IGlobalExtensionEnablementService');
+
+export interface IGlobalExtensionEnablementService {
+	_serviceBrand: undefined;
+	readonly onDidChangeEnablement: Event<readonly IExtensionIdentifier[]>;
+	getDisabledExtensions(): IExtensionIdentifier[];
+	enableExtension(extension: IExtensionIdentifier): Promise<boolean>;
+	disableExtension(extension: IExtensionIdentifier): Promise<boolean>;
+}
+
 export const ExtensionsLabel = localize('extensions', "Extensions");
 export const ExtensionsChannelId = 'extensions';
 export const PreferencesLabel = localize('preferences', "Preferences");

src/vs/workbench/services/extensionManagement/common/extensionEnablementService.ts

@@ -6,21 +6,18 @@
 import { localize } from 'vs/nls';
 import { Event, Emitter } from 'vs/base/common/event';
 import { Disposable } from 'vs/base/common/lifecycle';
-import { IExtensionManagementService, DidUninstallExtensionEvent, IExtensionIdentifier } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { IExtensionManagementService, DidUninstallExtensionEvent, IExtensionIdentifier, IGlobalExtensionEnablementService, ENABLED_EXTENSIONS_STORAGE_PATH, DISABLED_EXTENSIONS_STORAGE_PATH } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { IWorkbenchExtensionEnablementService, EnablementState, IExtensionManagementServerService } from 'vs/workbench/services/extensionManagement/common/extensionManagement';
 import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
-import { IStorageService, StorageScope, IWorkspaceStorageChangeEvent } from 'vs/platform/storage/common/storage';
+import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
-import { isUndefinedOrNull } from 'vs/base/common/types';
 import { ExtensionType, IExtension } from 'vs/platform/extensions/common/extensions';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { getExtensionKind } from 'vs/workbench/services/extensions/common/extensionsUtil';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { IProductService } from 'vs/platform/product/common/productService';
-
-const DISABLED_EXTENSIONS_STORAGE_PATH = 'extensionsIdentifiers/disabled';
-const ENABLED_EXTENSIONS_STORAGE_PATH = 'extensionsIdentifiers/enabled';
+import { StorageManager } from 'vs/platform/extensionManagement/common/extensionEnablementService';
 
 export class ExtensionEnablementService extends Disposable implements IWorkbenchExtensionEnablementService {
 
@@ -33,6 +30,7 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 
 	constructor(
 		@IStorageService storageService: IStorageService,
+		@IGlobalExtensionEnablementService protected readonly globalExtensionEnablementService: IGlobalExtensionEnablementService,
 		@IWorkspaceContextService private readonly contextService: IWorkspaceContextService,
 		@IWorkbenchEnvironmentService private readonly environmentService: IWorkbenchEnvironmentService,
 		@IExtensionManagementService private readonly extensionManagementService: IExtensionManagementService,
@@ -42,7 +40,7 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 	) {
 		super();
 		this.storageManger = this._register(new StorageManager(storageService));
-		this._register(this.storageManger.onDidChange(extensions => this.onDidChangeStorage(extensions)));
+		this._register(this.globalExtensionEnablementService.onDidChangeEnablement(extensions => this.onDidChangeExtensions(extensions)));
 		this._register(extensionManagementService.onDidUninstallExtension(this._onDidUninstallExtension, this));
 	}
 
@@ -61,20 +59,7 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 		if (this._isDisabledByExtensionKind(extension)) {
 			return EnablementState.DisabledByExtensionKind;
 		}
-		const identifier = extension.identifier;
-		if (this.hasWorkspace) {
-			if (this._getEnabledExtensions(StorageScope.WORKSPACE).filter(e => areSameExtensions(e, identifier))[0]) {
-				return EnablementState.EnabledWorkspace;
-			}
-
-			if (this._getDisabledExtensions(StorageScope.WORKSPACE).filter(e => areSameExtensions(e, identifier))[0]) {
-				return EnablementState.DisabledWorkspace;
-			}
-		}
-		if (this._getDisabledExtensions(StorageScope.GLOBAL).filter(e => areSameExtensions(e, identifier))[0]) {
-			return EnablementState.DisabledGlobally;
-		}
-		return EnablementState.EnabledGlobally;
+		return this._getEnablementState(extension.identifier);
 	}
 
 	canChangeEnablement(extension: IExtension): boolean {
@@ -167,128 +152,128 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 
 	private _getEnablementState(identifier: IExtensionIdentifier): EnablementState {
 		if (this.hasWorkspace) {
-			if (this._getEnabledExtensions(StorageScope.WORKSPACE).filter(e => areSameExtensions(e, identifier))[0]) {
+			if (this._getWorkspaceEnabledExtensions().filter(e => areSameExtensions(e, identifier))[0]) {
 				return EnablementState.EnabledWorkspace;
 			}
 
-			if (this._getDisabledExtensions(StorageScope.WORKSPACE).filter(e => areSameExtensions(e, identifier))[0]) {
+			if (this._getWorkspaceDisabledExtensions().filter(e => areSameExtensions(e, identifier))[0]) {
 				return EnablementState.DisabledWorkspace;
 			}
 		}
-		if (this._getDisabledExtensions(StorageScope.GLOBAL).filter(e => areSameExtensions(e, identifier))[0]) {
+		if (this.globalExtensionEnablementService.getDisabledExtensions().filter(e => areSameExtensions(e, identifier))[0]) {
 			return EnablementState.DisabledGlobally;
 		}
 		return EnablementState.EnabledGlobally;
 	}
 
-	private _enableExtension(identifier: IExtensionIdentifier): void {
-		this._removeFromDisabledExtensions(identifier, StorageScope.WORKSPACE);
-		this._removeFromEnabledExtensions(identifier, StorageScope.WORKSPACE);
-		this._removeFromDisabledExtensions(identifier, StorageScope.GLOBAL);
+	private _enableExtension(identifier: IExtensionIdentifier): Promise<boolean> {
+		this._removeFromWorkspaceDisabledExtensions(identifier);
+		this._removeFromWorkspaceEnabledExtensions(identifier);
+		return this.globalExtensionEnablementService.enableExtension(identifier);
 	}
 
-	private _disableExtension(identifier: IExtensionIdentifier): void {
-		this._removeFromDisabledExtensions(identifier, StorageScope.WORKSPACE);
-		this._removeFromEnabledExtensions(identifier, StorageScope.WORKSPACE);
-		this._addToDisabledExtensions(identifier, StorageScope.GLOBAL);
+	private _disableExtension(identifier: IExtensionIdentifier): Promise<boolean> {
+		this._removeFromWorkspaceDisabledExtensions(identifier);
+		this._removeFromWorkspaceEnabledExtensions(identifier);
+		return this.globalExtensionEnablementService.disableExtension(identifier);
 	}
 
 	private _enableExtensionInWorkspace(identifier: IExtensionIdentifier): void {
-		this._removeFromDisabledExtensions(identifier, StorageScope.WORKSPACE);
-		this._addToEnabledExtensions(identifier, StorageScope.WORKSPACE);
+		this._removeFromWorkspaceDisabledExtensions(identifier);
+		this._addToWorkspaceEnabledExtensions(identifier);
 	}
 
 	private _disableExtensionInWorkspace(identifier: IExtensionIdentifier): void {
-		this._addToDisabledExtensions(identifier, StorageScope.WORKSPACE);
-		this._removeFromEnabledExtensions(identifier, StorageScope.WORKSPACE);
+		this._addToWorkspaceDisabledExtensions(identifier);
+		this._removeFromWorkspaceEnabledExtensions(identifier);
 	}
 
-	private _addToDisabledExtensions(identifier: IExtensionIdentifier, scope: StorageScope): Promise<boolean> {
-		if (scope === StorageScope.WORKSPACE && !this.hasWorkspace) {
+	private _addToWorkspaceDisabledExtensions(identifier: IExtensionIdentifier): Promise<boolean> {
+		if (!this.hasWorkspace) {
 			return Promise.resolve(false);
 		}
-		let disabledExtensions = this._getDisabledExtensions(scope);
+		let disabledExtensions = this._getWorkspaceDisabledExtensions();
 		if (disabledExtensions.every(e => !areSameExtensions(e, identifier))) {
 			disabledExtensions.push(identifier);
-			this._setDisabledExtensions(disabledExtensions, scope);
+			this._setDisabledExtensions(disabledExtensions);
 			return Promise.resolve(true);
 		}
 		return Promise.resolve(false);
 	}
 
-	private _removeFromDisabledExtensions(identifier: IExtensionIdentifier, scope: StorageScope): boolean {
-		if (scope === StorageScope.WORKSPACE && !this.hasWorkspace) {
+	private async _removeFromWorkspaceDisabledExtensions(identifier: IExtensionIdentifier): Promise<boolean> {
+		if (!this.hasWorkspace) {
 			return false;
 		}
-		let disabledExtensions = this._getDisabledExtensions(scope);
+		let disabledExtensions = this._getWorkspaceDisabledExtensions();
 		for (let index = 0; index < disabledExtensions.length; index++) {
 			const disabledExtension = disabledExtensions[index];
 			if (areSameExtensions(disabledExtension, identifier)) {
 				disabledExtensions.splice(index, 1);
-				this._setDisabledExtensions(disabledExtensions, scope);
+				this._setDisabledExtensions(disabledExtensions);
 				return true;
 			}
 		}
 		return false;
 	}
 
-	private _addToEnabledExtensions(identifier: IExtensionIdentifier, scope: StorageScope): boolean {
-		if (scope === StorageScope.WORKSPACE && !this.hasWorkspace) {
+	private _addToWorkspaceEnabledExtensions(identifier: IExtensionIdentifier): boolean {
+		if (!this.hasWorkspace) {
 			return false;
 		}
-		let enabledExtensions = this._getEnabledExtensions(scope);
+		let enabledExtensions = this._getWorkspaceEnabledExtensions();
 		if (enabledExtensions.every(e => !areSameExtensions(e, identifier))) {
 			enabledExtensions.push(identifier);
-			this._setEnabledExtensions(enabledExtensions, scope);
+			this._setEnabledExtensions(enabledExtensions);
 			return true;
 		}
 		return false;
 	}
 
-	private _removeFromEnabledExtensions(identifier: IExtensionIdentifier, scope: StorageScope): boolean {
-		if (scope === StorageScope.WORKSPACE && !this.hasWorkspace) {
+	private _removeFromWorkspaceEnabledExtensions(identifier: IExtensionIdentifier): boolean {
+		if (!this.hasWorkspace) {
 			return false;
 		}
-		let enabledExtensions = this._getEnabledExtensions(scope);
+		let enabledExtensions = this._getWorkspaceEnabledExtensions();
 		for (let index = 0; index < enabledExtensions.length; index++) {
 			const disabledExtension = enabledExtensions[index];
 			if (areSameExtensions(disabledExtension, identifier)) {
 				enabledExtensions.splice(index, 1);
-				this._setEnabledExtensions(enabledExtensions, scope);
+				this._setEnabledExtensions(enabledExtensions);
 				return true;
 			}
 		}
 		return false;
 	}
 
-	protected _getEnabledExtensions(scope: StorageScope): IExtensionIdentifier[] {
-		return this._getExtensions(ENABLED_EXTENSIONS_STORAGE_PATH, scope);
+	protected _getWorkspaceEnabledExtensions(): IExtensionIdentifier[] {
+		return this._getExtensions(ENABLED_EXTENSIONS_STORAGE_PATH);
 	}
 
-	private _setEnabledExtensions(enabledExtensions: IExtensionIdentifier[], scope: StorageScope): void {
-		this._setExtensions(ENABLED_EXTENSIONS_STORAGE_PATH, enabledExtensions, scope);
+	private _setEnabledExtensions(enabledExtensions: IExtensionIdentifier[]): void {
+		this._setExtensions(ENABLED_EXTENSIONS_STORAGE_PATH, enabledExtensions);
 	}
 
-	protected _getDisabledExtensions(scope: StorageScope): IExtensionIdentifier[] {
-		return this._getExtensions(DISABLED_EXTENSIONS_STORAGE_PATH, scope);
+	protected _getWorkspaceDisabledExtensions(): IExtensionIdentifier[] {
+		return this._getExtensions(DISABLED_EXTENSIONS_STORAGE_PATH);
 	}
 
-	private _setDisabledExtensions(disabledExtensions: IExtensionIdentifier[], scope: StorageScope): void {
-		this._setExtensions(DISABLED_EXTENSIONS_STORAGE_PATH, disabledExtensions, scope);
+	private _setDisabledExtensions(disabledExtensions: IExtensionIdentifier[]): void {
+		this._setExtensions(DISABLED_EXTENSIONS_STORAGE_PATH, disabledExtensions);
 	}
 
-	private _getExtensions(storageId: string, scope: StorageScope): IExtensionIdentifier[] {
-		if (scope === StorageScope.WORKSPACE && !this.hasWorkspace) {
+	private _getExtensions(storageId: string): IExtensionIdentifier[] {
+		if (!this.hasWorkspace) {
 			return [];
 		}
-		return this.storageManger.get(storageId, scope);
+		return this.storageManger.get(storageId, StorageScope.WORKSPACE);
 	}
 
-	private _setExtensions(storageId: string, extensions: IExtensionIdentifier[], scope: StorageScope): void {
-		this.storageManger.set(storageId, extensions, scope);
+	private _setExtensions(storageId: string, extensions: IExtensionIdentifier[]): void {
+		this.storageManger.set(storageId, extensions, StorageScope.WORKSPACE);
 	}
 
-	private async onDidChangeStorage(extensionIdentifiers: IExtensionIdentifier[]): Promise<void> {
+	private async onDidChangeExtensions(extensionIdentifiers: ReadonlyArray<IExtensionIdentifier>): Promise<void> {
 		const installedExtensions = await this.extensionManagementService.getInstalled();
 		const extensions = installedExtensions.filter(installedExtension => extensionIdentifiers.some(identifier => areSameExtensions(identifier, installedExtension.identifier)));
 		this._onEnablementChanged.fire(extensions);
@@ -301,80 +286,9 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 	}
 
 	private _reset(extension: IExtensionIdentifier) {
-		this._removeFromDisabledExtensions(extension, StorageScope.WORKSPACE);
-		this._removeFromEnabledExtensions(extension, StorageScope.WORKSPACE);
-		this._removeFromDisabledExtensions(extension, StorageScope.GLOBAL);
-	}
-}
-
-class StorageManager extends Disposable {
-
-	private storage: { [key: string]: string } = Object.create(null);
-
-	private _onDidChange: Emitter<IExtensionIdentifier[]> = this._register(new Emitter<IExtensionIdentifier[]>());
-	readonly onDidChange: Event<IExtensionIdentifier[]> = this._onDidChange.event;
-
-	constructor(private storageService: IStorageService) {
-		super();
-		this._register(storageService.onDidChangeStorage(e => this.onDidStorageChange(e)));
-	}
-
-	get(key: string, scope: StorageScope): IExtensionIdentifier[] {
-		let value: string;
-		if (scope === StorageScope.GLOBAL) {
-			if (isUndefinedOrNull(this.storage[key])) {
-				this.storage[key] = this._get(key, scope);
-			}
-			value = this.storage[key];
-		} else {
-			value = this._get(key, scope);
-		}
-		return JSON.parse(value);
-	}
-
-	set(key: string, value: IExtensionIdentifier[], scope: StorageScope): void {
-		let newValue: string = JSON.stringify(value.map(({ id, uuid }) => (<IExtensionIdentifier>{ id, uuid })));
-		const oldValue = this._get(key, scope);
-		if (oldValue !== newValue) {
-			if (scope === StorageScope.GLOBAL) {
-				if (value.length) {
-					this.storage[key] = newValue;
-				} else {
-					delete this.storage[key];
-				}
-			}
-			this._set(key, value.length ? newValue : undefined, scope);
-		}
-	}
-
-	private onDidStorageChange(workspaceStorageChangeEvent: IWorkspaceStorageChangeEvent): void {
-		if (workspaceStorageChangeEvent.scope === StorageScope.GLOBAL) {
-			if (!isUndefinedOrNull(this.storage[workspaceStorageChangeEvent.key])) {
-				const newValue = this._get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
-				if (newValue !== this.storage[workspaceStorageChangeEvent.key]) {
-					const oldValues = this.get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
-					delete this.storage[workspaceStorageChangeEvent.key];
-					const newValues = this.get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
-					const added = oldValues.filter(oldValue => !newValues.some(newValue => areSameExtensions(oldValue, newValue)));
-					const removed = newValues.filter(newValue => !oldValues.some(oldValue => areSameExtensions(oldValue, newValue)));
-					if (added.length || removed.length) {
-						this._onDidChange.fire([...added, ...removed]);
-					}
-				}
-			}
-		}
-	}
-
-	private _get(key: string, scope: StorageScope): string {
-		return this.storageService.get(key, scope, '[]');
-	}
-
-	private _set(key: string, value: string | undefined, scope: StorageScope): void {
-		if (value) {
-			this.storageService.store(key, value, scope);
-		} else {
-			this.storageService.remove(key, scope);
-		}
+		this._removeFromWorkspaceDisabledExtensions(extension);
+		this._removeFromWorkspaceEnabledExtensions(extension);
+		this.globalExtensionEnablementService.enableExtension(extension);
 	}
 }
 

src/vs/workbench/services/extensionManagement/test/electron-browser/extensionEnablementService.test.ts

@@ -11,7 +11,7 @@ import { TestInstantiationService } from 'vs/platform/instantiation/test/common/
 import { Emitter } from 'vs/base/common/event';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
-import { IStorageService, InMemoryStorageService, StorageScope } from 'vs/platform/storage/common/storage';
+import { IStorageService, InMemoryStorageService } from 'vs/platform/storage/common/storage';
 import { IExtensionContributions, ExtensionType, IExtension } from 'vs/platform/extensions/common/extensions';
 import { isUndefinedOrNull } from 'vs/base/common/types';
 import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
@@ -22,8 +22,9 @@ import { REMOTE_HOST_SCHEME } from 'vs/platform/remote/common/remoteHosts';
 import { assign } from 'vs/base/common/objects';
 import { TestConfigurationService } from 'vs/platform/configuration/test/common/testConfigurationService';
 import { productService } from 'vs/workbench/test/workbenchTestServices';
+import { GlobalExtensionEnablementService } from 'vs/platform/extensionManagement/common/extensionEnablementService';
 
-function storageService(instantiationService: TestInstantiationService): IStorageService {
+function createStorageService(instantiationService: TestInstantiationService): IStorageService {
 	let service = instantiationService.get(IStorageService);
 	if (!service) {
 		let workspaceContextService = instantiationService.get(IWorkspaceContextService);
@@ -39,10 +40,12 @@ function storageService(instantiationService: TestInstantiationService): IStorag
 
 export class TestExtensionEnablementService extends ExtensionEnablementService {
 	constructor(instantiationService: TestInstantiationService) {
+		const storageService = createStorageService(instantiationService);
 		const extensionManagementService = instantiationService.get(IExtensionManagementService) || instantiationService.stub(IExtensionManagementService, { onDidInstallExtension: new Emitter<DidInstallExtensionEvent>().event, onDidUninstallExtension: new Emitter<DidUninstallExtensionEvent>().event } as IExtensionManagementService);
 		const extensionManagementServerService = instantiationService.get(IExtensionManagementServerService) || instantiationService.stub(IExtensionManagementServerService, <IExtensionManagementServerService>{ localExtensionManagementServer: { extensionManagementService } });
 		super(
-			storageService(instantiationService),
+			storageService,
+			new GlobalExtensionEnablementService(storageService),
 			instantiationService.get(IWorkspaceContextService),
 			instantiationService.get(IWorkbenchEnvironmentService) || instantiationService.stub(IWorkbenchEnvironmentService, { configuration: Object.create(null) } as IWorkbenchEnvironmentService),
 			extensionManagementService,
@@ -53,13 +56,13 @@ export class TestExtensionEnablementService extends ExtensionEnablementService {
 	}
 
 	public reset(): void {
-		let extensions = this._getDisabledExtensions(StorageScope.GLOBAL);
-		for (const e of this._getDisabledExtensions(StorageScope.WORKSPACE)) {
+		let extensions = this.globalExtensionEnablementService.getDisabledExtensions();
+		for (const e of this._getWorkspaceDisabledExtensions()) {
 			if (!extensions.some(r => areSameExtensions(r, e))) {
 				extensions.push(e);
 			}
 		}
-		const workspaceEnabledExtensions = this._getEnabledExtensions(StorageScope.WORKSPACE);
+		const workspaceEnabledExtensions = this._getWorkspaceEnabledExtensions();
 		if (workspaceEnabledExtensions.length) {
 			extensions = extensions.filter(r => !workspaceEnabledExtensions.some(e => areSameExtensions(e, r)));
 		}

src/vs/workbench/workbench.common.main.ts

@@ -87,7 +87,8 @@ import 'vs/workbench/services/filesConfiguration/common/filesConfigurationServic
 
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { ExtensionGalleryService } from 'vs/platform/extensionManagement/common/extensionGalleryService';
-import { IExtensionGalleryService } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { GlobalExtensionEnablementService } from 'vs/platform/extensionManagement/common/extensionEnablementService';
+import { IExtensionGalleryService, IGlobalExtensionEnablementService } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { ContextViewService } from 'vs/platform/contextview/browser/contextViewService';
 import { IContextViewService } from 'vs/platform/contextview/browser/contextView';
 import { IListService, ListService } from 'vs/platform/list/browser/listService';
@@ -110,6 +111,7 @@ import { DownloadService } from 'vs/platform/download/common/downloadService';
 import { OpenerService } from 'vs/editor/browser/services/openerService';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 
+registerSingleton(IGlobalExtensionEnablementService, GlobalExtensionEnablementService);
 registerSingleton(IExtensionGalleryService, ExtensionGalleryService, true);
 registerSingleton(IContextViewService, ContextViewService, true);
 registerSingleton(IListService, ListService, true);