chore(vscode): update to 1.53.2

These conflicts will be resolved in the following commits. We do it this way so
that PR review is possible.

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

@@ -9,6 +9,7 @@ import { isUNC } from 'vs/base/common/extpath';
 import { Schemas } from 'vs/base/common/network';
 import { sep } from 'vs/base/common/path';
 import { URI } from 'vs/base/common/uri';
+import { ILogService } from 'vs/platform/log/common/log';
 import { IRemoteConnectionData } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { IRequestService } from 'vs/platform/request/common/request';
 import { getWebviewContentMimeType } from 'vs/platform/webview/common/mimeTypes';
@@ -24,7 +25,8 @@ export namespace WebviewResourceResponse {
 
 		constructor(
 			public readonly stream: VSBufferReadableStream,
-			public readonly mimeType: string
+			public readonly etag: string | undefined,
+			public readonly mimeType: string,
 		) { }
 	}
 
@@ -35,7 +37,7 @@ export namespace WebviewResourceResponse {
 }
 
 interface FileReader {
-	readFileStream(resource: URI): Promise<VSBufferReadableStream>;
+	readFileStream(resource: URI): Promise<{ stream: VSBufferReadableStream, etag?: string }>;
 }
 
 export async function loadLocalResource(
@@ -48,8 +50,14 @@ export async function loadLocalResource(
 	},
 	fileReader: FileReader,
 	requestService: IRequestService,
+	logService: ILogService,
 ): Promise<WebviewResourceResponse.StreamResponse> {
+	logService.debug(`loadLocalResource - being. requestUri=${requestUri}`);
+
 	let resourceToLoad = getResourceToLoad(requestUri, options.roots);
+
+	logService.debug(`loadLocalResource - found resource to load. requestUri=${requestUri}, resourceToLoad=${resourceToLoad}`);
+
 	if (!resourceToLoad) {
 		return WebviewResourceResponse.AccessDenied;
 	}
@@ -63,17 +71,23 @@ export async function loadLocalResource(
 
 	if (resourceToLoad.scheme === Schemas.http || resourceToLoad.scheme === Schemas.https) {
 		const response = await requestService.request({ url: resourceToLoad.toString(true) }, CancellationToken.None);
+		logService.debug(`loadLocalResource - Loaded over http(s). requestUri=${requestUri}, response=${response.res.statusCode}`);
+
 		if (response.res.statusCode === 200) {
-			return new WebviewResourceResponse.StreamSuccess(response.stream, mime);
+			return new WebviewResourceResponse.StreamSuccess(response.stream, undefined, mime);
 		}
 		return WebviewResourceResponse.Failed;
 	}
 
 	try {
 		const contents = await fileReader.readFileStream(resourceToLoad);
-		return new WebviewResourceResponse.StreamSuccess(contents, mime);
+		logService.debug(`loadLocalResource - Loaded using fileReader. requestUri=${requestUri}`);
+
+		return new WebviewResourceResponse.StreamSuccess(contents.stream, contents.etag, mime);
 	} catch (err) {
+		logService.debug(`loadLocalResource - Error using fileReader. requestUri=${requestUri}`);
 		console.log(err);
+
 		return WebviewResourceResponse.Failed;
 	}
 }

lib/vscode/src/vs/platform/webview/common/webviewPortMapping.ts

@@ -19,7 +19,7 @@ export interface IWebviewPortMapping {
  */
 export class WebviewPortMappingManager implements IDisposable {
 
-	private readonly _tunnels = new Map<number, Promise<RemoteTunnel>>();
+	private readonly _tunnels = new Map<number, RemoteTunnel>();
 
 	constructor(
 		private readonly _getExtensionLocation: () => URI | undefined,
@@ -60,19 +60,19 @@ export class WebviewPortMappingManager implements IDisposable {
 		return undefined;
 	}
 
-	dispose() {
+	async dispose() {
 		for (const tunnel of this._tunnels.values()) {
-			tunnel.then(tunnel => tunnel.dispose());
+			await tunnel.dispose();
 		}
 		this._tunnels.clear();
 	}
 
-	private getOrCreateTunnel(remoteAuthority: IAddress, remotePort: number): Promise<RemoteTunnel> | undefined {
+	private async getOrCreateTunnel(remoteAuthority: IAddress, remotePort: number): Promise<RemoteTunnel | undefined> {
 		const existing = this._tunnels.get(remotePort);
 		if (existing) {
 			return existing;
 		}
-		const tunnel = this.tunnelService.openTunnel({ getAddress: async () => remoteAuthority }, undefined, remotePort);
+		const tunnel = await this.tunnelService.openTunnel({ getAddress: async () => remoteAuthority }, undefined, remotePort);
 		if (tunnel) {
 			this._tunnels.set(remotePort, tunnel);
 		}

lib/vscode/src/vs/platform/webview/electron-main/webviewMainService.ts

@@ -8,6 +8,7 @@ import { VSBuffer } from 'vs/base/common/buffer';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
 import { IFileService } from 'vs/platform/files/common/files';
+import { ILogService } from 'vs/platform/log/common/log';
 import { ITunnelService } from 'vs/platform/remote/common/tunnel';
 import { IRequestService } from 'vs/platform/request/common/request';
 import { IWebviewManagerService, RegisterWebviewMetadata, WebviewWebContentsId, WebviewWindowId } from 'vs/platform/webview/common/webviewManagerService';
@@ -24,12 +25,13 @@ export class WebviewMainService extends Disposable implements IWebviewManagerSer
 
 	constructor(
 		@IFileService fileService: IFileService,
+		@ILogService logService: ILogService,
 		@IRequestService requestService: IRequestService,
 		@ITunnelService tunnelService: ITunnelService,
 		@IWindowsMainService private readonly windowsMainService: IWindowsMainService,
 	) {
 		super();
-		this.protocolProvider = this._register(new WebviewProtocolProvider(fileService, requestService, windowsMainService));
+		this.protocolProvider = this._register(new WebviewProtocolProvider(fileService, logService, requestService, windowsMainService));
 		this.portMappingProvider = this._register(new WebviewPortMappingProvider(tunnelService));
 	}
 

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

@@ -10,6 +10,7 @@ import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { FileAccess, Schemas } from 'vs/base/common/network';
 import { URI } from 'vs/base/common/uri';
 import { FileOperationError, FileOperationResult, IFileService } from 'vs/platform/files/common/files';
+import { ILogService } from 'vs/platform/log/common/log';
 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';
@@ -38,8 +39,9 @@ export class WebviewProtocolProvider extends Disposable {
 
 	constructor(
 		@IFileService private readonly fileService: IFileService,
+		@ILogService private readonly logService: ILogService,
 		@IRequestService private readonly requestService: IRequestService,
-		@IWindowsMainService readonly windowsMainService: IWindowsMainService,
+		@IWindowsMainService private readonly windowsMainService: IWindowsMainService,
 	) {
 		super();
 
@@ -125,7 +127,10 @@ export class WebviewProtocolProvider extends Disposable {
 		}
 	}
 
-	private async handleWebviewRequest(request: Electron.Request, callback: any) {
+	private async handleWebviewRequest(
+		request: Electron.ProtocolRequest,
+		callback: (response: string | Electron.ProtocolResponse) => void
+	) {
 		try {
 			const uri = URI.parse(request.url);
 			const entry = WebviewProtocolProvider.validWebviewFilePaths.get(uri.path);
@@ -144,8 +149,8 @@ export class WebviewProtocolProvider extends Disposable {
 	}
 
 	private async handleWebviewResourceRequest(
-		request: Electron.Request,
-		callback: (stream?: NodeJS.ReadableStream | Electron.StreamProtocolResponse | undefined) => void
+		request: Electron.ProtocolRequest,
+		callback: (stream: NodeJS.ReadableStream | Electron.ProtocolResponse) => void
 	) {
 		try {
 			const uri = URI.parse(request.url);
@@ -170,10 +175,14 @@ export class WebviewProtocolProvider extends Disposable {
 					};
 				}
 
-				const fileService = {
-					readFileStream: async (resource: URI): Promise<VSBufferReadableStream> => {
+				const fileReader = {
+					readFileStream: async (resource: URI): Promise<{ stream: VSBufferReadableStream, etag?: string }> => {
 						if (resource.scheme === Schemas.file) {
-							return (await this.fileService.readFileStream(resource)).value;
+							const result = (await this.fileService.readFileStream(resource));
+							return {
+								stream: result.value,
+								etag: result.etag
+							};
 						}
 
 						// Unknown uri scheme. Try delegating the file read back to the renderer
@@ -196,7 +205,7 @@ export class WebviewProtocolProvider extends Disposable {
 							throw new FileOperationError('Could not read file', FileOperationResult.FILE_NOT_FOUND);
 						}
 
-						return bufferToStream(result);
+						return { stream: bufferToStream(result), etag: undefined };
 					}
 				};
 
@@ -205,29 +214,55 @@ export class WebviewProtocolProvider extends Disposable {
 					roots: metadata.localResourceRoots,
 					remoteConnectionData: metadata.remoteConnectionData,
 					rewriteUri,
-				}, fileService, this.requestService);
+				}, fileReader, this.requestService, this.logService);
 
 				if (result.type === WebviewResourceResponse.Type.Success) {
+					const cacheHeaders: Record<string, string> = result.etag ? {
+						'ETag': result.etag,
+						'Cache-Control': 'no-cache'
+					} : {};
+
+					const ifNoneMatch = request.headers['If-None-Match'];
+					if (ifNoneMatch && result.etag === ifNoneMatch) {
+						/*
+						 * Note that the server generating a 304 response MUST
+						 * generate any of the following header fields that would
+						 * have been sent in a 200 (OK) response to the same request:
+						 * Cache-Control, Content-Location, Date, ETag, Expires, and Vary.
+						 * (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match)
+						 */
+						return callback({
+							statusCode: 304, // not modified
+							data: undefined, // The request fails if `data` is not set
+							headers: {
+								'Content-Type': result.mimeType,
+								'Access-Control-Allow-Origin': '*',
+								...cacheHeaders
+							}
+						});
+					}
+
 					return callback({
 						statusCode: 200,
 						data: this.streamToNodeReadable(result.stream),
 						headers: {
 							'Content-Type': result.mimeType,
 							'Access-Control-Allow-Origin': '*',
+							...cacheHeaders
 						}
 					});
 				}
 
 				if (result.type === WebviewResourceResponse.Type.AccessDenied) {
 					console.error('Webview: Cannot load resource outside of protocol root');
-					return callback({ data: null, statusCode: 401 });
+					return callback({ data: undefined, statusCode: 401 });
 				}
 			}
 		} catch {
 			// noop
 		}
 
-		return callback({ data: null, statusCode: 404 });
+		return callback({ data: undefined, statusCode: 404 });
 	}
 
 	public didLoadResource(requestId: number, content: VSBuffer | undefined) {