Restore old remote uri normalization for remote uris

For #100442

When we moved the webview resource protocol to the main process, I updated the uri normalization logic so that it could load remote resources properly. This however broke VSO since their resources are still loaded from the renderer process.

This change restores the old normalization for the renderer side resource loader.

src/vs/platform/webview/common/resourceLoader.ts

@@ -11,7 +11,6 @@ import { sep } from 'vs/base/common/path';
 import { URI } from 'vs/base/common/uri';
 import { IFileService } from 'vs/platform/files/common/files';
 import { IRemoteConnectionData } from 'vs/platform/remote/common/remoteAuthorityResolver';
-import { REMOTE_HOST_SCHEME } from 'vs/platform/remote/common/remoteHosts';
 import { IRequestService } from 'vs/platform/request/common/request';
 import { getWebviewContentMimeType } from 'vs/platform/webview/common/mimeTypes';
 
@@ -42,31 +41,29 @@ export async function loadLocalResource(
 		extensionLocation: URI | undefined;
 		roots: ReadonlyArray<URI>;
 		remoteConnectionData?: IRemoteConnectionData | null;
+		rewriteUri?: (uri: URI) => URI,
 	},
 	fileService: IFileService,
 	requestService: IRequestService,
 ): Promise<WebviewResourceResponse.StreamResponse> {
-	const resourceToLoad = getResourceToLoad(requestUri, options.roots);
+	let resourceToLoad = getResourceToLoad(requestUri, options.roots);
 	if (!resourceToLoad) {
 		return WebviewResourceResponse.AccessDenied;
 	}
+
 	const mime = getWebviewContentMimeType(requestUri); // Use the original path for the mime
 
-	if (options.remoteConnectionData) {
-		// Remote uris must go to the resolved server.
-		if (resourceToLoad.scheme === Schemas.vscodeRemote || (options.extensionLocation?.scheme === REMOTE_HOST_SCHEME)) {
-			const scheme = options.remoteConnectionData.host === 'localhost' || options.remoteConnectionData.host === '127.0.0.1' ? 'http' : 'https';
-			const uri = URI.parse(`${scheme}://${options.remoteConnectionData.host}:${options.remoteConnectionData.port}`).with({
-				path: '/vscode-remote-resource',
-				query: `tkn=${options.remoteConnectionData.connectionToken}&path=${encodeURIComponent(resourceToLoad.path)}`,
-			});
-
-			const response = await requestService.request({ url: uri.toString(true) }, CancellationToken.None);
-			if (response.res.statusCode === 200) {
-				return new WebviewResourceResponse.StreamSuccess(response.stream, mime);
-			}
-			return WebviewResourceResponse.Failed;
+	// Perform extra normalization if needed
+	if (options.rewriteUri) {
+		resourceToLoad = options.rewriteUri(resourceToLoad);
+	}
+
+	if (resourceToLoad.scheme === Schemas.http || resourceToLoad.scheme === Schemas.https) {
+		const response = await requestService.request({ url: resourceToLoad.toString(true) }, CancellationToken.None);
+		if (response.res.statusCode === 200) {
+			return new WebviewResourceResponse.StreamSuccess(response.stream, mime);
 		}
+		return WebviewResourceResponse.Failed;
 	}
 
 	try {

src/vs/platform/webview/electron-main/webviewProtocolProvider.ts

@@ -13,6 +13,7 @@ import { IFileService } from 'vs/platform/files/common/files';
 import { IRemoteConnectionData } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { IRequestService } from 'vs/platform/request/common/request';
 import { loadLocalResource, webviewPartitionId, WebviewResourceResponse } from 'vs/platform/webview/common/resourceLoader';
+import { REMOTE_HOST_SCHEME } from 'vs/platform/remote/common/remoteHosts';
 
 interface WebviewMetadata {
 	readonly extensionLocation: URI | undefined;
@@ -39,11 +40,31 @@ export class WebviewProtocolProvider extends Disposable {
 				const id = uri.authority;
 				const metadata = this.webviewMetadata.get(id);
 				if (metadata) {
+
+					// Try to further rewrite remote uris so that they go to the resolved server on the main thread
+					let rewriteUri: undefined | ((uri: URI) => URI);
+					if (metadata.remoteConnectionData) {
+						rewriteUri = (uri) => {
+							if (metadata.remoteConnectionData) {
+								if (uri.scheme === Schemas.vscodeRemote || (metadata.extensionLocation?.scheme === REMOTE_HOST_SCHEME)) {
+									const scheme = metadata.remoteConnectionData.host === 'localhost' || metadata.remoteConnectionData.host === '127.0.0.1' ? 'http' : 'https';
+									return URI.parse(`${scheme}://${metadata.remoteConnectionData.host}:${metadata.remoteConnectionData.port}`).with({
+										path: '/vscode-remote-resource',
+										query: `tkn=${metadata.remoteConnectionData.connectionToken}&path=${encodeURIComponent(uri.path)}`,
+									});
+								}
+							}
+							return uri;
+						};
+					}
+
 					const result = await loadLocalResource(uri, {
 						extensionLocation: metadata.extensionLocation,
 						roots: metadata.localResourceRoots,
 						remoteConnectionData: metadata.remoteConnectionData,
+						rewriteUri,
 					}, this.fileService, this.requestService);
+
 					if (result.type === WebviewResourceResponse.Type.Success) {
 						return callback({
 							statusCode: 200,

src/vs/workbench/contrib/webview/browser/webviewElement.ts

@@ -6,6 +6,7 @@
 import { addDisposableListener } from 'vs/base/browser/dom';
 import { streamToBuffer } from 'vs/base/common/buffer';
 import { IDisposable } from 'vs/base/common/lifecycle';
+import { Schemas } from 'vs/base/common/network';
 import { isWeb } from 'vs/base/common/platform';
 import { URI } from 'vs/base/common/uri';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
@@ -13,6 +14,7 @@ import { IEnvironmentService } from 'vs/platform/environment/common/environment'
 import { IFileService } from 'vs/platform/files/common/files';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IRemoteAuthorityResolverService } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { REMOTE_HOST_SCHEME } from 'vs/platform/remote/common/remoteHosts';
 import { ITunnelService } from 'vs/platform/remote/common/tunnel';
 import { IRequestService } from 'vs/platform/request/common/request';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
@@ -146,11 +148,31 @@ export class IFrameWebview extends BaseWebview<HTMLIFrameElement> implements Web
 		try {
 			const remoteAuthority = this._workbenchEnvironmentService.configuration.remoteAuthority;
 			const remoteConnectionData = remoteAuthority ? this._remoteAuthorityResolverService.getConnectionData(remoteAuthority) : null;
+			const extensionLocation = this.extension?.location;
+
+			// If we are loading a file resource from a remote extension, rewrite the uri to go remote
+			let rewriteUri: undefined | ((uri: URI) => URI);
+			if (extensionLocation?.scheme === REMOTE_HOST_SCHEME) {
+				rewriteUri = (uri) => {
+					if (uri.scheme === Schemas.file && extensionLocation?.scheme === REMOTE_HOST_SCHEME) {
+						return URI.from({
+							scheme: REMOTE_HOST_SCHEME,
+							authority: extensionLocation.authority,
+							path: '/vscode-resource',
+							query: JSON.stringify({
+								requestResourcePath: uri.path
+							})
+						});
+					}
+					return uri;
+				};
+			}
 
 			const result = await loadLocalResource(uri, {
-				extensionLocation: this.extension?.location,
+				extensionLocation: extensionLocation,
 				roots: this.content.options.localResourceRoots || [],
-				remoteConnectionData
+				remoteConnectionData,
+				rewriteUri,
 			}, this.fileService, this.requestService);
 
 			if (result.type === WebviewResourceResponse.Type.Success) {