Revert "clean up"

This reverts commit e84a2290.

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

@@ -3,7 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { ILocalExtension, IGalleryExtension, IExtensionIdentifier, IReportedExtension } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { ILocalExtension, IGalleryExtension, IExtensionIdentifier, IReportedExtension, IExtensionManifest } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { compareIgnoreCase } from 'vs/base/common/strings';
 
 export function areSameExtensions(a: IExtensionIdentifier, b: IExtensionIdentifier): boolean {
@@ -116,4 +117,27 @@ export function getMaliciousExtensionsSet(report: IReportedExtension[]): Set<str
 	}
 
 	return result;
+}
+
+const nonWorkspaceExtensions = new Set<string>();
+
+export function isWorkspaceExtension(manifest: IExtensionManifest, configurationService: IConfigurationService): boolean {
+	const extensionId = getGalleryExtensionId(manifest.publisher, manifest.name);
+	const configuredWorkspaceExtensions = configurationService.getValue<string[]>('_workbench.workspaceExtensions') || [];
+	if (configuredWorkspaceExtensions.length) {
+		if (configuredWorkspaceExtensions.indexOf(extensionId) !== -1) {
+			return true;
+		}
+		if (configuredWorkspaceExtensions.indexOf(`-${extensionId}`) !== -1) {
+			return false;
+		}
+	}
+
+	if (manifest.main) {
+		if ((manifest.categories || []).indexOf('Workspace Extension') !== -1) {
+			return true;
+		}
+		return !nonWorkspaceExtensions.has(extensionId);
+	}
+	return false;
 }
\ No newline at end of file

src/vs/platform/extensionManagement/node/multiExtensionManagement.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, EventMultiplexer } from 'vs/base/common/event';
+import {
+	IExtensionManagementService, ILocalExtension, IGalleryExtension, LocalExtensionType, InstallExtensionEvent, DidInstallExtensionEvent, IExtensionIdentifier, DidUninstallExtensionEvent, IReportedExtension, IGalleryMetadata,
+	IExtensionManagementServerService, IExtensionManagementServer, IExtensionGalleryService
+} from 'vs/platform/extensionManagement/common/extensionManagement';
+import { flatten } from 'vs/base/common/arrays';
+import { isWorkspaceExtension, areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { URI } from 'vs/base/common/uri';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { CancellationToken } from 'vs/base/common/cancellation';
+
+export class MulitExtensionManagementService extends Disposable implements IExtensionManagementService {
+
+	_serviceBrand: any;
+
+	readonly onInstallExtension: Event<InstallExtensionEvent>;
+	readonly onDidInstallExtension: Event<DidInstallExtensionEvent>;
+	readonly onUninstallExtension: Event<IExtensionIdentifier>;
+	readonly onDidUninstallExtension: Event<DidUninstallExtensionEvent>;
+
+	private readonly servers: IExtensionManagementServer[];
+	private readonly localServer: IExtensionManagementServer;
+	private readonly otherServers: IExtensionManagementServer[];
+
+	constructor(
+		@IExtensionManagementServerService private extensionManagementServerService: IExtensionManagementServerService,
+		@IExtensionGalleryService private extensionGalleryService: IExtensionGalleryService,
+		@IConfigurationService private configurationService: IConfigurationService
+	) {
+		super();
+		this.servers = this.extensionManagementServerService.extensionManagementServers;
+		this.localServer = this.extensionManagementServerService.getLocalExtensionManagementServer();
+		this.otherServers = this.servers.filter(s => s !== this.localServer);
+
+		this.onInstallExtension = this._register(this.servers.reduce((emitter: EventMultiplexer<InstallExtensionEvent>, server) => { emitter.add(server.extensionManagementService.onInstallExtension); return emitter; }, new EventMultiplexer<InstallExtensionEvent>())).event;
+		this.onDidInstallExtension = this._register(this.servers.reduce((emitter: EventMultiplexer<DidInstallExtensionEvent>, server) => { emitter.add(server.extensionManagementService.onDidInstallExtension); return emitter; }, new EventMultiplexer<DidInstallExtensionEvent>())).event;
+		this.onUninstallExtension = this._register(this.servers.reduce((emitter: EventMultiplexer<IExtensionIdentifier>, server) => { emitter.add(server.extensionManagementService.onUninstallExtension); return emitter; }, new EventMultiplexer<IExtensionIdentifier>())).event;
+		this.onDidUninstallExtension = this._register(this.servers.reduce((emitter: EventMultiplexer<DidUninstallExtensionEvent>, server) => { emitter.add(server.extensionManagementService.onDidUninstallExtension); return emitter; }, new EventMultiplexer<DidUninstallExtensionEvent>())).event;
+	}
+
+	getInstalled(type?: LocalExtensionType): Promise<ILocalExtension[]> {
+		return Promise.all(this.servers.map(({ extensionManagementService }) => extensionManagementService.getInstalled(type)))
+			.then(result => flatten(result));
+	}
+
+	uninstall(extension: ILocalExtension, force?: boolean): Promise<void> {
+		return this.getServer(extension).extensionManagementService.uninstall(extension, force);
+	}
+
+	reinstallFromGallery(extension: ILocalExtension): Promise<void> {
+		return this.getServer(extension).extensionManagementService.reinstallFromGallery(extension);
+	}
+
+	updateMetadata(extension: ILocalExtension, metadata: IGalleryMetadata): Promise<ILocalExtension> {
+		return this.getServer(extension).extensionManagementService.updateMetadata(extension, metadata);
+	}
+
+	zip(extension: ILocalExtension): Promise<URI> {
+		throw new Error('Not Supported');
+	}
+
+	unzip(zipLocation: URI, type: LocalExtensionType): Promise<IExtensionIdentifier> {
+		return Promise.all(this.servers.map(({ extensionManagementService }) => extensionManagementService.unzip(zipLocation, type))).then(() => null);
+	}
+
+	install(vsix: URI): Promise<IExtensionIdentifier> {
+		return this.localServer.extensionManagementService.install(vsix)
+			.then(extensionIdentifer => this.localServer.extensionManagementService.getInstalled(LocalExtensionType.User)
+				.then(installed => {
+					const extension = installed.filter(i => areSameExtensions(i.identifier, extensionIdentifer))[0];
+					if (this.otherServers.length && extension && isWorkspaceExtension(extension.manifest, this.configurationService)) {
+						return Promise.all(this.otherServers.map(server => server.extensionManagementService.install(vsix)))
+							.then(() => extensionIdentifer);
+					}
+					return extensionIdentifer;
+				}));
+	}
+
+	installFromGallery(gallery: IGalleryExtension): Promise<void> {
+		if (this.otherServers.length === 0) {
+			return this.localServer.extensionManagementService.installFromGallery(gallery);
+		}
+		return this.extensionGalleryService.getManifest(gallery, CancellationToken.None)
+			.then(manifest => {
+				const servers = isWorkspaceExtension(manifest, this.configurationService) ? this.servers : [this.localServer];
+				return Promise.all(servers.map(server => server.extensionManagementService.installFromGallery(gallery)))
+					.then(() => null);
+			});
+	}
+
+	getExtensionsReport(): Promise<IReportedExtension[]> {
+		return this.extensionManagementServerService.getLocalExtensionManagementServer().extensionManagementService.getExtensionsReport();
+	}
+
+	private getServer(extension: ILocalExtension): IExtensionManagementServer {
+		return this.extensionManagementServerService.getExtensionManagementServer(extension.location);
+	}
+}
\ No newline at end of file

src/vs/workbench/electron-browser/shell.ts

@@ -92,6 +92,7 @@ import { EventType, addDisposableListener, addClass } from 'vs/base/browser/dom'
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 import { OpenerService } from 'vs/editor/browser/services/openerService';
 import { SearchHistoryService } from 'vs/workbench/services/search/node/searchHistoryService';
+import { MulitExtensionManagementService } from 'vs/platform/extensionManagement/node/multiExtensionManagement';
 import { ExtensionManagementServerService } from 'vs/workbench/services/extensions/node/extensionManagementServerService';
 import { DefaultURITransformer } from 'vs/base/common/uriIpc';
 import { ExtensionGalleryService } from 'vs/platform/extensionManagement/node/extensionGalleryService';
@@ -391,7 +392,7 @@ export class WorkbenchShell extends Disposable {
 		const extensionManagementChannel = getDelayedChannel<IExtensionManagementChannel>(sharedProcess.then(c => c.getChannel('extensions')));
 		const extensionManagementChannelClient = new ExtensionManagementChannelClient(extensionManagementChannel, DefaultURITransformer);
 		serviceCollection.set(IExtensionManagementServerService, new SyncDescriptor(ExtensionManagementServerService, extensionManagementChannelClient));
-		serviceCollection.set(IExtensionManagementService, extensionManagementChannelClient);
+		serviceCollection.set(IExtensionManagementService, new SyncDescriptor(MulitExtensionManagementService));
 
 		const extensionEnablementService = this._register(instantiationService.createInstance(ExtensionEnablementService));
 		serviceCollection.set(IExtensionEnablementService, extensionEnablementService);