Merge pull request microsoft#154822 from microsoft/sandy081/shared-process-request-service

Shared process - Delegate requests to main

Author: sandy081

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

@@ -53,7 +53,6 @@ import { FollowerLogService, LoggerChannelClient, LogLevelChannelClient } from '
 import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
 import product from 'vs/platform/product/common/product';
 import { IProductService } from 'vs/platform/product/common/productService';
-import { RequestService } from 'vs/platform/request/browser/requestService';
 import { IRequestService } from 'vs/platform/request/common/request';
 import { ISharedProcessConfiguration } from 'vs/platform/sharedProcess/node/sharedProcess';
 import { IStorageService } from 'vs/platform/storage/common/storage';
@@ -106,6 +105,7 @@ import { IPolicyService, NullPolicyService } from 'vs/platform/policy/common/pol
 import { UserDataProfilesNativeService } from 'vs/platform/userDataProfile/electron-sandbox/userDataProfile';
 import { OneDataSystemWebAppender } from 'vs/platform/telemetry/browser/1dsAppender';
 import { DefaultExtensionsProfileInitService } from 'vs/platform/extensionManagement/electron-sandbox/defaultExtensionsProfileInit';
+import { SharedProcessRequestService } from 'vs/platform/request/electron-browser/sharedProcessRequestService';
 
 class SharedProcessMain extends Disposable {
 
@@ -254,7 +254,7 @@ class SharedProcessMain extends Disposable {
 		services.set(IUriIdentityService, new UriIdentityService(fileService));
 
 		// Request
-		services.set(IRequestService, new SyncDescriptor(RequestService));
+		services.set(IRequestService, new SharedProcessRequestService(mainProcessService, configurationService, logService));
 
 		// Checksum
 		services.set(IChecksumService, new SyncDescriptor(ChecksumService));

src/vs/code/electron-main/app.ts

@@ -104,6 +104,8 @@ import { PolicyChannel } from 'vs/platform/policy/common/policyIpc';
 import { IUserDataProfilesMainService } from 'vs/platform/userDataProfile/electron-main/userDataProfile';
 import { IDefaultExtensionsProfileInitService } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { DefaultExtensionsProfileInitHandler } from 'vs/platform/extensionManagement/electron-main/defaultExtensionsProfileInit';
+import { RequestChannel } from 'vs/platform/request/common/requestIpc';
+import { IRequestService } from 'vs/platform/request/common/request';
 
 /**
  * The main VS Code application. There will only ever be one instance,
@@ -728,6 +730,10 @@ export class CodeApplication extends Disposable {
 		mainProcessElectronServer.registerChannel('userDataProfiles', userDataProfilesService);
 		sharedProcessClient.then(client => client.registerChannel('userDataProfiles', userDataProfilesService));
 
+		// Request
+		const requestService = new RequestChannel(accessor.get(IRequestService));
+		sharedProcessClient.then(client => client.registerChannel('request', requestService));
+
 		// Update
 		const updateChannel = new UpdateChannel(accessor.get(IUpdateService));
 		mainProcessElectronServer.registerChannel('update', updateChannel);

src/vs/platform/request/common/requestIpc.ts

@@ -26,31 +26,32 @@ export class RequestChannel implements IServerChannel {
 		throw new Error('Invalid listen');
 	}
 
-	call(context: any, command: string, args?: any): Promise<any> {
+	call(context: any, command: string, args?: any, token: CancellationToken = CancellationToken.None): Promise<any> {
 		switch (command) {
-			case 'request': return this.service.request(args[0], CancellationToken.None)
+			case 'request': return this.service.request(args[0], token)
 				.then(async ({ res, stream }) => {
 					const buffer = await streamToBuffer(stream);
 					return <RequestResponse>[{ statusCode: res.statusCode, headers: res.headers }, buffer];
 				});
+			case 'resolveProxy': return this.service.resolveProxy(args[0]);
 		}
 		throw new Error('Invalid call');
 	}
 }
 
-export class RequestChannelClient {
+export class RequestChannelClient implements IRequestService {
 
 	declare readonly _serviceBrand: undefined;
 
 	constructor(private readonly channel: IChannel) { }
 
 	async request(options: IRequestOptions, token: CancellationToken): Promise<IRequestContext> {
-		return RequestChannelClient.request(this.channel, options, token);
+		const [res, buffer] = await this.channel.call<RequestResponse>('request', [options], token);
+		return { res, stream: bufferToStream(buffer) };
 	}
 
-	static async request(channel: IChannel, options: IRequestOptions, token: CancellationToken): Promise<IRequestContext> {
-		const [res, buffer] = await channel.call<RequestResponse>('request', [options]);
-		return { res, stream: bufferToStream(buffer) };
+	async resolveProxy(url: string): Promise<string | undefined> {
+		return this.channel.call<string | undefined>('resolveProxy', [url]);
 	}
 
 }

src/vs/platform/request/electron-browser/sharedProcessRequestService.ts

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { IRequestContext, IRequestOptions } from 'vs/base/parts/request/common/request';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { IMainProcessService } from 'vs/platform/ipc/electron-sandbox/services';
+import { ILogService } from 'vs/platform/log/common/log';
+import { RequestService } from 'vs/platform/request/browser/requestService';
+import { IRequestService } from 'vs/platform/request/common/request';
+import { RequestChannelClient } from 'vs/platform/request/common/requestIpc';
+
+export class SharedProcessRequestService implements IRequestService {
+
+	declare readonly _serviceBrand: undefined;
+
+	private readonly browserRequestService: IRequestService;
+	private readonly mainRequestService: IRequestService;
+
+	constructor(
+		mainProcessService: IMainProcessService,
+		private readonly configurationService: IConfigurationService,
+		private readonly logService: ILogService,
+	) {
+		this.browserRequestService = new RequestService(configurationService, logService);
+		this.mainRequestService = new RequestChannelClient(mainProcessService.getChannel('request'));
+	}
+
+	request(options: IRequestOptions, token: CancellationToken): Promise<IRequestContext> {
+		return this.getRequestService().request(options, token);
+	}
+
+	async resolveProxy(url: string): Promise<string | undefined> {
+		return this.getRequestService().resolveProxy(url);
+	}
+
+	private getRequestService(): IRequestService {
+		if (this.configurationService.getValue('developer.sharedProcess.useBrowserRequestService') === true) {
+			this.logService.trace('Using browser request service');
+			return this.browserRequestService;
+		}
+		this.logService.trace('Using main request service');
+		return this.mainRequestService;
+	}
+}

src/vs/workbench/services/request/browser/requestService.ts

@@ -41,7 +41,7 @@ export class BrowserRequestService extends RequestService {
 	}
 
 	private _makeRemoteRequest(connection: IRemoteAgentConnection, options: IRequestOptions, token: CancellationToken): Promise<IRequestContext> {
-		return connection.withChannel('request', channel => RequestChannelClient.request(channel, options, token));
+		return connection.withChannel('request', channel => new RequestChannelClient(channel).request(options, token));
 	}
 }