remote: add resource provider api for embedders (microsoft#181969)

Initially I was looking at VS Code providing some service worker code
to plop in in an opaque way for embedders. But that was convoluted both
for an API and consumers. For example, if we provided an agnostic handler
for this, it would clash with the Workbox types (a popular service worker
toolkit we use in vscode.dev) since they don't expose the original events.

Instead, take a more minimal approach, allowing embedders to hook in
themselves and provide a route that they want to use for the 'proxy'.

This was quite easy to implement as a variation in vscode.dev. Example
of extension icons loading:

![](https://memes.peet.io/img/23-05-8da09054-2717-4fca-b9b9-c605718f22f0.png)

Author: connor4312

src/vs/platform/remote/browser/remoteAuthorityResolverService.ts

@@ -104,8 +104,9 @@ export class RemoteAuthorityResolverService extends Disposable implements IRemot
 	_setResolvedAuthority(resolvedAuthority: ResolvedAuthority, options?: ResolvedOptions): void {
 		if (this._resolveAuthorityRequests.has(resolvedAuthority.authority)) {
 			const request = this._resolveAuthorityRequests.get(resolvedAuthority.authority)!;
+			// For non-websocket types, it's expected the embedder passes a `remoteResourceProvider`
+			// which is wrapped to a `IResourceUriProvider` and is not handled here.
 			if (resolvedAuthority.connectTo.type === RemoteConnectionType.WebSocket) {
-				// todo@connor4312 need to implement some kind of loopback for ext host based messaging
 				RemoteAuthorities.set(resolvedAuthority.authority, resolvedAuthority.connectTo.host, resolvedAuthority.connectTo.port);
 			}
 			if (resolvedAuthority.connectionToken) {

src/vs/workbench/browser/web.api.ts

@@ -173,6 +173,15 @@ export interface IWorkbenchConstructionOptions {
 	 */
 	readonly editSessionId?: string;
 
+	/**
+	 * Resource delegation handler that allows for loading of resources when
+	 * using remote resolvers.
+	 *
+	 * This is exclusive with {@link resourceUriProvider}. `resourceUriProvider`
+	 * should be used if a {@link webSocketFactory} is used, and will be preferred.
+	 */
+	readonly remoteResourceProvider?: IRemoteResourceProvider;
+
 	//#endregion
 
 
@@ -760,3 +769,38 @@ export interface IDevelopmentOptions {
 	 */
 	readonly enableSmokeTestDriver?: boolean;
 }
+
+/**
+ * Utility provided in the {@link WorkbenchOptions} which allows loading resources
+ * when remote resolvers are used in the web.
+ */
+export interface IRemoteResourceProvider {
+	/**
+	 * Path the workbench should delegate requests to. The embedder should
+	 * install a service worker on this path and emit {@link onDidReceiveRequest}
+	 * events when requests come in for that path.
+	 */
+	readonly path: string;
+
+	/**
+	 * Event that should fire when requests are made on the {@link pathPrefix}.
+	 */
+	readonly onDidReceiveRequest: Event<IRemoteResourceRequest>;
+}
+
+/**
+ * todo@connor4312: this may eventually gain more properties like method and
+ * headers, but for now we only deal with GET requests.
+ */
+export interface IRemoteResourceRequest {
+	/**
+	 * Request URI. Generally will begin with the current
+	 * origin and {@link IRemoteResourceProvider.pathPrefix}.
+	 */
+	uri: URI;
+
+	/**
+	 * A method called by the editor to issue a response to the request.
+	 */
+	respondWith(statusCode: number, body: Uint8Array): void;
+}

src/vs/workbench/browser/web.main.ts

@@ -88,6 +88,7 @@ import { VSBuffer } from 'vs/base/common/buffer';
 import { IStoredWorkspace } from 'vs/platform/workspaces/common/workspaces';
 import { UserDataProfileInitializer } from 'vs/workbench/services/userDataProfile/browser/userDataProfileInit';
 import { UserDataSyncInitializer } from 'vs/workbench/services/userDataSync/browser/userDataSyncInit';
+import { BrowserRemoteResourceLoader } from 'vs/workbench/services/remote/browser/browserRemoteResourceHandler';
 import { BufferLogger } from 'vs/platform/log/common/bufferLog';
 import { FileLoggerService } from 'vs/platform/log/common/fileLog';
 
@@ -275,7 +276,9 @@ export class BrowserMain extends Disposable {
 
 		// Remote
 		const connectionToken = environmentService.options.connectionToken || getCookieValue(connectionTokenCookieName);
-		const remoteAuthorityResolverService = new RemoteAuthorityResolverService(!environmentService.expectsResolverExtension, connectionToken, this.configuration.resourceUriProvider, productService, logService);
+		const remoteResourceLoader = this.configuration.remoteResourceProvider ? new BrowserRemoteResourceLoader(fileService, this.configuration.remoteResourceProvider) : undefined;
+		const resourceUriProvider = this.configuration.resourceUriProvider ?? remoteResourceLoader?.getResourceUriProvider();
+		const remoteAuthorityResolverService = new RemoteAuthorityResolverService(!environmentService.expectsResolverExtension, connectionToken, resourceUriProvider, productService, logService);
 		serviceCollection.set(IRemoteAuthorityResolverService, remoteAuthorityResolverService);
 
 		// Signing

src/vs/workbench/services/remote/browser/browserRemoteResourceHandler.ts

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { VSBuffer } from 'vs/base/common/buffer';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { FileOperationError, FileOperationResult, IFileContent, IFileService } from 'vs/platform/files/common/files';
+import { IRemoteResourceProvider, IResourceUriProvider } from 'vs/workbench/browser/web.api';
+
+export class BrowserRemoteResourceLoader extends Disposable {
+	constructor(
+		@IFileService fileService: IFileService,
+		private readonly provider: IRemoteResourceProvider,
+	) {
+		super();
+
+		this._register(provider.onDidReceiveRequest(async request => {
+			let uri: UriComponents;
+			try {
+				uri = JSON.parse(decodeURIComponent(request.uri.query));
+			} catch {
+				return request.respondWith(404, new Uint8Array());
+			}
+
+			let content: IFileContent;
+			try {
+				content = await fileService.readFile(URI.from(uri, true));
+			} catch (e) {
+				const str = VSBuffer.fromString(e.message).buffer;
+				if (e instanceof FileOperationError && e.fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
+					return request.respondWith(404, str);
+				} else {
+					return request.respondWith(500, str);
+				}
+			}
+
+			request.respondWith(200, content.value.buffer);
+		}));
+	}
+
+	public getResourceUriProvider(): IResourceUriProvider {
+		const baseUri = URI.parse(document.location.href);
+		return uri => baseUri.with({
+			path: this.provider.path,
+			query: JSON.stringify(uri),
+		});
+	}
+}