sandbox - get rid of IMainProcessService2

src/vs/code/electron-browser/issue/issueReporterMain.ts

@@ -26,7 +26,8 @@ import { isRemoteDiagnosticError, SystemInfo } from 'vs/platform/diagnostics/com
 import { EnvironmentService, INativeEnvironmentService } from 'vs/platform/environment/node/environmentService';
 import { InstantiationService } from 'vs/platform/instantiation/common/instantiationService';
 import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
-import { IMainProcessService, MainProcessService } from 'vs/platform/ipc/electron-browser/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
+import { MainProcessService } from 'vs/platform/ipc/electron-browser/mainProcessService';
 import { ISharedProcessService } from 'vs/platform/ipc/electron-browser/sharedProcessService';
 import { ISettingsSearchIssueReporterData, IssueReporterData, IssueReporterExtensionData, IssueReporterFeatures, IssueReporterStyles, IssueType } from 'vs/platform/issue/common/issue';
 import { getLogLevel, ILogService } from 'vs/platform/log/common/log';

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

@@ -40,7 +40,7 @@ import { NodeCachedDataCleaner } from 'vs/code/electron-browser/sharedProcess/co
 import { LanguagePackCachedDataCleaner } from 'vs/code/electron-browser/sharedProcess/contrib/languagePackCachedDataCleaner';
 import { StorageDataCleaner } from 'vs/code/electron-browser/sharedProcess/contrib/storageDataCleaner';
 import { LogsDataCleaner } from 'vs/code/electron-browser/sharedProcess/contrib/logsDataCleaner';
-import { IMainProcessService } from 'vs/platform/ipc/electron-browser/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { SpdLogService } from 'vs/platform/log/node/spdlogService';
 import { DiagnosticsService, IDiagnosticsService } from 'vs/platform/diagnostics/node/diagnosticsService';
 import { DiagnosticsChannel } from 'vs/platform/diagnostics/node/diagnosticsIpc';
@@ -89,7 +89,12 @@ interface ISharedProcessInitData {
 const eventPrefix = 'monacoworkbench';
 
 class MainProcessService implements IMainProcessService {
-	constructor(private server: Server, private mainRouter: StaticRouter) { }
+
+	constructor(
+		public readonly windowId: number,
+		private server: Server,
+		private mainRouter: StaticRouter
+	) { }
 
 	_serviceBrand: undefined;
 
@@ -121,7 +126,7 @@ async function main(server: Server, initData: ISharedProcessInitData, configurat
 	disposables.add(logService);
 	logService.info('main', JSON.stringify(configuration));
 
-	const mainProcessService = new MainProcessService(server, mainRouter);
+	const mainProcessService = new MainProcessService(configuration.windowId, server, mainRouter);
 	services.set(IMainProcessService, mainProcessService);
 
 	// Files

src/vs/platform/driver/electron-browser/driver.ts

@@ -6,7 +6,7 @@
 import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { WindowDriverChannel, WindowDriverRegistryChannelClient } from 'vs/platform/driver/node/driver';
 import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import * as electron from 'electron';
 import { timeout } from 'vs/base/common/async';
 import { BaseWindowDriver } from 'vs/platform/driver/browser/baseDriver';
@@ -47,7 +47,7 @@ class WindowDriver extends BaseWindowDriver {
 
 export async function registerWindowDriver(accessor: ServicesAccessor, windowId: number): Promise<IDisposable> {
 	const instantiationService = accessor.get(IInstantiationService);
-	const mainProcessService = accessor.get(IMainProcessService2);
+	const mainProcessService = accessor.get(IMainProcessService);
 
 	const windowDriver = instantiationService.createInstance(WindowDriver);
 	const windowDriverChannel = new WindowDriverChannel(windowDriver);

src/vs/platform/ipc/common/mainProcessService.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
+
+export const IMainProcessService = createDecorator<IMainProcessService>('mainProcessService');
+
+export interface IMainProcessService {
+
+	_serviceBrand: undefined;
+
+	readonly windowId: number;
+
+	getChannel(channelName: string): IChannel;
+
+	registerChannel(channelName: string, channel: IServerChannel<string>): void;
+}

src/vs/platform/ipc/electron-browser/mainProcessService.ts

@@ -3,21 +3,10 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
 import { Client } from 'vs/base/parts/ipc/electron-browser/ipc.electron-browser';
 import { Disposable } from 'vs/base/common/lifecycle';
-
-export const IMainProcessService = createDecorator<IMainProcessService>('mainProcessService');
-
-export interface IMainProcessService {
-
-	_serviceBrand: undefined;
-
-	getChannel(channelName: string): IChannel;
-
-	registerChannel(channelName: string, channel: IServerChannel<string>): void;
-}
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 
 export class MainProcessService extends Disposable implements IMainProcessService {
 
@@ -26,7 +15,7 @@ export class MainProcessService extends Disposable implements IMainProcessServic
 	private mainProcessConnection: Client;
 
 	constructor(
-		windowId: number
+		public readonly windowId: number
 	) {
 		super();
 

src/vs/platform/ipc/electron-sandbox/mainProcessService.ts

@@ -3,25 +3,12 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
 import { Client } from 'vs/base/parts/ipc/electron-sandbox/ipc.electron-sandbox';
 import { Disposable } from 'vs/base/common/lifecycle';
 
-export const IMainProcessService2 = createDecorator<IMainProcessService2>('mainProcessService2');
-
-export interface IMainProcessService2 {
-
-	_serviceBrand: undefined;
-
-	readonly windowId: number;
-
-	getChannel(channelName: string): IChannel;
-
-	registerChannel(channelName: string, channel: IServerChannel<string>): void;
-}
-
-export class MainProcessService2 extends Disposable implements IMainProcessService2 {
+export class MainProcessService extends Disposable implements IMainProcessService {
 
 	_serviceBrand: undefined;
 

src/vs/workbench/contrib/debug/electron-sandbox/extensionHostDebugService.ts

@@ -5,13 +5,13 @@
 
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { IExtensionHostDebugService } from 'vs/platform/debug/common/extensionHostDebug';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { ExtensionHostDebugChannelClient, ExtensionHostDebugBroadcastChannel } from 'vs/platform/debug/common/extensionHostDebugIpc';
 
 export class ExtensionHostDebugService extends ExtensionHostDebugChannelClient {
 
 	constructor(
-		@IMainProcessService2 readonly mainProcessService: IMainProcessService2
+		@IMainProcessService readonly mainProcessService: IMainProcessService
 	) {
 		super(mainProcessService.getChannel(ExtensionHostDebugBroadcastChannel.ChannelName));
 	}

src/vs/workbench/electron-browser/desktop.main.ts

@@ -30,7 +30,8 @@ import { IConfigurationService } from 'vs/platform/configuration/common/configur
 import { IStorageService } from 'vs/platform/storage/common/storage';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { registerWindowDriver } from 'vs/platform/driver/electron-browser/driver';
-import { IMainProcessService2, MainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
+import { MainProcessService } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
 import { RemoteAuthorityResolverService } from 'vs/platform/remote/electron-browser/remoteAuthorityResolverService';
 import { IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { RemoteAgentService } from 'vs/workbench/services/remote/electron-browser/remoteAgentServiceImpl';
@@ -170,8 +171,8 @@ class DesktopMain extends Disposable {
 		// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 		// Main Process
-		const mainProcessService = this._register(new MainProcessService2(this.configuration.windowId));
-		serviceCollection.set(IMainProcessService2, mainProcessService);
+		const mainProcessService = this._register(new MainProcessService(this.configuration.windowId));
+		serviceCollection.set(IMainProcessService, mainProcessService);
 
 		// Environment
 		serviceCollection.set(IWorkbenchEnvironmentService, this.environmentService);
@@ -297,7 +298,7 @@ class DesktopMain extends Disposable {
 		}
 	}
 
-	private async createStorageService(payload: IWorkspaceInitializationPayload, logService: ILogService, mainProcessService: IMainProcessService2): Promise<NativeStorageService> {
+	private async createStorageService(payload: IWorkspaceInitializationPayload, logService: ILogService, mainProcessService: IMainProcessService): Promise<NativeStorageService> {
 		const globalStorageDatabase = new GlobalStorageDatabaseChannelClient(mainProcessService.getChannel('storage'));
 		const storageService = new NativeStorageService(globalStorageDatabase, logService, this.environmentService);
 

src/vs/workbench/services/electron/electron-browser/electronService.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IElectronService } from 'vs/platform/electron/node/electron';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { INativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-browser/environmentService';
 import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
@@ -15,7 +15,7 @@ export class ElectronService {
 	_serviceBrand: undefined;
 
 	constructor(
-		@IMainProcessService2 mainProcessService: IMainProcessService2,
+		@IMainProcessService mainProcessService: IMainProcessService,
 		@IWorkbenchEnvironmentService environmentService: INativeWorkbenchEnvironmentService
 	) {
 		return createChannelSender<IElectronService>(mainProcessService.getChannel('electron'), { context: environmentService.configuration.windowId });

src/vs/workbench/services/issue/electron-sandbox/issueService.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IIssueService } from 'vs/platform/issue/common/issue';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 
@@ -12,7 +12,7 @@ export class IssueService {
 
 	_serviceBrand: undefined;
 
-	constructor(@IMainProcessService2 mainProcessService: IMainProcessService2) {
+	constructor(@IMainProcessService mainProcessService: IMainProcessService) {
 		return createChannelSender<IIssueService>(mainProcessService.getChannel('issue'));
 	}
 }

src/vs/workbench/services/log/electron-browser/logService.ts

@@ -6,7 +6,7 @@
 import { DelegatedLogService, ILogService, ConsoleLogInMainService, ConsoleLogService, MultiplexLogService } from 'vs/platform/log/common/log';
 import { BufferLogService } from 'vs/platform/log/common/bufferLog';
 import { NativeWorkbenchEnvironmentService } from 'vs/workbench/services/environment/electron-browser/environmentService';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { LoggerChannelClient, FollowerLogService } from 'vs/platform/log/common/logIpc';
 import { SpdLogService } from 'vs/platform/log/node/spdlogService';
 import { DisposableStore } from 'vs/base/common/lifecycle';
@@ -20,7 +20,7 @@ export class DesktopLogService extends DelegatedLogService {
 	private readonly windowId: number;
 	private readonly environmentService: NativeWorkbenchEnvironmentService;
 
-	constructor(windowId: number, mainProcessService: IMainProcessService2, environmentService: NativeWorkbenchEnvironmentService) {
+	constructor(windowId: number, mainProcessService: IMainProcessService, environmentService: NativeWorkbenchEnvironmentService) {
 
 		const disposables = new DisposableStore();
 		const loggerClient = new LoggerChannelClient(mainProcessService.getChannel('logger'));

src/vs/workbench/services/menubar/electron-sandbox/menubarService.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IMenubarService } from 'vs/platform/menubar/common/menubar';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 
@@ -12,7 +12,7 @@ export class MenubarService {
 
 	_serviceBrand: undefined;
 
-	constructor(@IMainProcessService2 mainProcessService: IMainProcessService2) {
+	constructor(@IMainProcessService mainProcessService: IMainProcessService) {
 		return createChannelSender<IMenubarService>(mainProcessService.getChannel('menubar'));
 	}
 }

src/vs/workbench/services/sharedProcess/electron-browser/sharedProcessService.ts

@@ -6,7 +6,7 @@
 import { Client } from 'vs/base/parts/ipc/common/ipc.net';
 import { connect } from 'vs/base/parts/ipc/node/ipc.net';
 import { IChannel, IServerChannel, getDelayedChannel } from 'vs/base/parts/ipc/common/ipc';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { ISharedProcessService } from 'vs/platform/ipc/electron-browser/sharedProcessService';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
@@ -20,7 +20,7 @@ export class SharedProcessService implements ISharedProcessService {
 	private sharedProcessMainChannel: IChannel;
 
 	constructor(
-		@IMainProcessService2 mainProcessService: IMainProcessService2,
+		@IMainProcessService mainProcessService: IMainProcessService,
 		@IWorkbenchEnvironmentService environmentService: INativeWorkbenchEnvironmentService
 	) {
 		this.sharedProcessMainChannel = mainProcessService.getChannel('sharedProcess');

src/vs/workbench/services/update/electron-sandbox/updateService.ts

@@ -6,7 +6,7 @@
 import { IChannel } from 'vs/base/parts/ipc/common/ipc';
 import { Event, Emitter } from 'vs/base/common/event';
 import { IUpdateService, State } from 'vs/platform/update/common/update';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 
 export class NativeUpdateService implements IUpdateService {
@@ -21,7 +21,7 @@ export class NativeUpdateService implements IUpdateService {
 
 	private channel: IChannel;
 
-	constructor(@IMainProcessService2 mainProcessService: IMainProcessService2) {
+	constructor(@IMainProcessService mainProcessService: IMainProcessService) {
 		this.channel = mainProcessService.getChannel('update');
 
 		// always set this._state as the state changes

src/vs/workbench/services/url/electron-browser/urlService.ts

@@ -5,7 +5,7 @@
 
 import { IURLService, IURLHandler, IOpenURLOptions } from 'vs/platform/url/common/url';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { URLHandlerChannel } from 'vs/platform/url/common/urlIpc';
 import { URLService } from 'vs/platform/url/node/urlService';
 import { IOpenerService, IOpener, matchesScheme } from 'vs/platform/opener/common/opener';
@@ -26,7 +26,7 @@ export class RelayURLService extends URLService implements IURLHandler, IOpener
 	private urlService: IURLService;
 
 	constructor(
-		@IMainProcessService2 mainProcessService: IMainProcessService2,
+		@IMainProcessService mainProcessService: IMainProcessService,
 		@IOpenerService openerService: IOpenerService,
 		@IWorkbenchEnvironmentService private readonly environmentService: INativeWorkbenchEnvironmentService,
 		@IElectronService private electronService: IElectronService

src/vs/workbench/services/userDataSync/electron-sandbox/storageKeysSyncRegistryService.ts

@@ -5,13 +5,13 @@
 
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { IStorageKeysSyncRegistryService } from 'vs/platform/userDataSync/common/storageKeys';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { StorageKeysSyncRegistryChannelClient } from 'vs/platform/userDataSync/common/userDataSyncIpc';
 
 class StorageKeysSyncRegistryService extends StorageKeysSyncRegistryChannelClient implements IStorageKeysSyncRegistryService {
 
 	constructor(
-		@IMainProcessService2 mainProcessService: IMainProcessService2
+		@IMainProcessService mainProcessService: IMainProcessService
 	) {
 		super(mainProcessService.getChannel('storageKeysSyncRegistryService'));
 	}

src/vs/workbench/services/workspaces/electron-sandbox/workspacesService.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IWorkspacesService } from 'vs/platform/workspaces/common/workspaces';
-import { IMainProcessService2 } from 'vs/platform/ipc/electron-sandbox/mainProcessService';
+import { IMainProcessService } from 'vs/platform/ipc/common/mainProcessService';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
 
@@ -13,7 +13,7 @@ export class NativeWorkspacesService {
 	_serviceBrand: undefined;
 
 	constructor(
-		@IMainProcessService2 mainProcessService: IMainProcessService2
+		@IMainProcessService mainProcessService: IMainProcessService
 	) {
 		return createChannelSender<IWorkspacesService>(mainProcessService.getChannel('workspaces'), { context: mainProcessService.windowId });
 	}