Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

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

@@ -0,0 +1,26 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { getMediaMime, MIME_UNKNOWN } from 'vs/base/common/mime';
+import { extname } from 'vs/base/common/path';
+import { URI } from 'vs/base/common/uri';
+
+const webviewMimeTypes = new Map([
+	['.svg', 'image/svg+xml'],
+	['.txt', 'text/plain'],
+	['.css', 'text/css'],
+	['.js', 'application/javascript'],
+	['.json', 'application/json'],
+	['.html', 'text/html'],
+	['.htm', 'text/html'],
+	['.xhtml', 'application/xhtml+xml'],
+	['.oft', 'font/otf'],
+	['.xml', 'application/xml'],
+]);
+
+export function getWebviewContentMimeType(resource: URI): string {
+	const ext = extname(resource.fsPath).toLowerCase();
+	return webviewMimeTypes.get(ext) || getMediaMime(resource.fsPath) || MIME_UNKNOWN;
+}

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

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { VSBufferReadableStream } from 'vs/base/common/buffer';
+import { CancellationToken } from 'vs/base/common/cancellation';
+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 { IRemoteConnectionData } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { IRequestService } from 'vs/platform/request/common/request';
+import { getWebviewContentMimeType } from 'vs/platform/webview/common/mimeTypes';
+
+
+export const webviewPartitionId = 'webview';
+
+export namespace WebviewResourceResponse {
+	export enum Type { Success, Failed, AccessDenied }
+
+	export class StreamSuccess {
+		readonly type = Type.Success;
+
+		constructor(
+			public readonly stream: VSBufferReadableStream,
+			public readonly mimeType: string
+		) { }
+	}
+
+	export const Failed = { type: Type.Failed } as const;
+	export const AccessDenied = { type: Type.AccessDenied } as const;
+
+	export type StreamResponse = StreamSuccess | typeof Failed | typeof AccessDenied;
+}
+
+interface FileReader {
+	readFileStream(resource: URI): Promise<VSBufferReadableStream>;
+}
+
+export async function loadLocalResource(
+	requestUri: URI,
+	options: {
+		extensionLocation: URI | undefined;
+		roots: ReadonlyArray<URI>;
+		remoteConnectionData?: IRemoteConnectionData | null;
+		rewriteUri?: (uri: URI) => URI,
+	},
+	fileReader: FileReader,
+	requestService: IRequestService,
+): Promise<WebviewResourceResponse.StreamResponse> {
+	let resourceToLoad = getResourceToLoad(requestUri, options.roots);
+	if (!resourceToLoad) {
+		return WebviewResourceResponse.AccessDenied;
+	}
+
+	const mime = getWebviewContentMimeType(requestUri); // Use the original path for the mime
+
+	// 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 {
+		const contents = await fileReader.readFileStream(resourceToLoad);
+		return new WebviewResourceResponse.StreamSuccess(contents, mime);
+	} catch (err) {
+		console.log(err);
+		return WebviewResourceResponse.Failed;
+	}
+}
+
+function getResourceToLoad(
+	requestUri: URI,
+	roots: ReadonlyArray<URI>
+): URI | undefined {
+	const normalizedPath = normalizeRequestPath(requestUri);
+
+	for (const root of roots) {
+		if (containsResource(root, normalizedPath)) {
+			return normalizedPath;
+		}
+	}
+
+	return undefined;
+}
+
+function normalizeRequestPath(requestUri: URI) {
+	if (requestUri.scheme === Schemas.vscodeWebviewResource) {
+		// The `vscode-webview-resource` scheme has the following format:
+		//
+		// vscode-webview-resource://id/scheme//authority?/path
+		//
+
+		// Encode requestUri.path so that URI.parse can properly parse special characters like '#', '?', etc.
+		const resourceUri = URI.parse(encodeURIComponent(requestUri.path).replace(/%2F/gi, '/').replace(/^\/([a-z0-9\-]+)(\/{1,2})/i, (_: string, scheme: string, sep: string) => {
+			if (sep.length === 1) {
+				return `${scheme}:///`; // Add empty authority.
+			} else {
+				return `${scheme}://`; // Url has own authority.
+			}
+		}));
+		return resourceUri.with({
+			query: requestUri.query,
+			fragment: requestUri.fragment
+		});
+	} else {
+		return requestUri;
+	}
+}
+
+function containsResource(root: URI, resource: URI): boolean {
+	let rootPath = root.fsPath + (root.fsPath.endsWith(sep) ? '' : sep);
+	let resourceFsPath = resource.fsPath;
+
+	if (isUNC(root.fsPath) && isUNC(resource.fsPath)) {
+		rootPath = rootPath.toLowerCase();
+		resourceFsPath = resourceFsPath.toLowerCase();
+	}
+
+	return resourceFsPath.startsWith(rootPath);
+}

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

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { UriComponents } from 'vs/base/common/uri';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IRemoteConnectionData } from 'vs/platform/remote/common/remoteAuthorityResolver';
+import { IWebviewPortMapping } from 'vs/platform/webview/common/webviewPortMapping';
+
+export const IWebviewManagerService = createDecorator<IWebviewManagerService>('webviewManagerService');
+
+export interface IWebviewManagerService {
+	_serviceBrand: unknown;
+
+	registerWebview(id: string, windowId: number, metadata: RegisterWebviewMetadata): Promise<void>;
+	unregisterWebview(id: string): Promise<void>;
+	updateWebviewMetadata(id: string, metadataDelta: Partial<RegisterWebviewMetadata>): Promise<void>;
+
+	didLoadResource(requestId: number, content: VSBuffer | undefined): void;
+
+	setIgnoreMenuShortcuts(webContentsId: number, enabled: boolean): Promise<void>;
+}
+
+export interface RegisterWebviewMetadata {
+	readonly extensionLocation: UriComponents | undefined;
+	readonly localResourceRoots: readonly UriComponents[];
+	readonly remoteConnectionData: IRemoteConnectionData | null;
+	readonly portMappings: readonly IWebviewPortMapping[];
+}

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

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { Schemas } from 'vs/base/common/network';
+import { URI } from 'vs/base/common/uri';
+import { IAddress } from 'vs/platform/remote/common/remoteAgentConnection';
+import { extractLocalHostUriMetaDataForPortMapping, ITunnelService, RemoteTunnel } from 'vs/platform/remote/common/tunnel';
+
+export interface IWebviewPortMapping {
+	webviewPort: number;
+	extensionHostPort: number;
+}
+
+/**
+ * Manages port mappings for a single webview.
+ */
+export class WebviewPortMappingManager implements IDisposable {
+
+	private readonly _tunnels = new Map<number, Promise<RemoteTunnel>>();
+
+	constructor(
+		private readonly _getExtensionLocation: () => URI | undefined,
+		private readonly _getMappings: () => readonly IWebviewPortMapping[],
+		private readonly tunnelService: ITunnelService
+	) { }
+
+	public async getRedirect(resolveAuthority: IAddress | null | undefined, url: string): Promise<string | undefined> {
+		const uri = URI.parse(url);
+		const requestLocalHostInfo = extractLocalHostUriMetaDataForPortMapping(uri);
+		if (!requestLocalHostInfo) {
+			return undefined;
+		}
+
+		for (const mapping of this._getMappings()) {
+			if (mapping.webviewPort === requestLocalHostInfo.port) {
+				const extensionLocation = this._getExtensionLocation();
+				if (extensionLocation && extensionLocation.scheme === Schemas.vscodeRemote) {
+					const tunnel = resolveAuthority && await this.getOrCreateTunnel(resolveAuthority, mapping.extensionHostPort);
+					if (tunnel) {
+						if (tunnel.tunnelLocalPort === mapping.webviewPort) {
+							return undefined;
+						}
+						return encodeURI(uri.with({
+							authority: `127.0.0.1:${tunnel.tunnelLocalPort}`,
+						}).toString(true));
+					}
+				}
+
+				if (mapping.webviewPort !== mapping.extensionHostPort) {
+					return encodeURI(uri.with({
+						authority: `${requestLocalHostInfo.address}:${mapping.extensionHostPort}`
+					}).toString(true));
+				}
+			}
+		}
+
+		return undefined;
+	}
+
+	dispose() {
+		for (const tunnel of this._tunnels.values()) {
+			tunnel.then(tunnel => tunnel.dispose());
+		}
+		this._tunnels.clear();
+	}
+
+	private 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);
+		if (tunnel) {
+			this._tunnels.set(remotePort, tunnel);
+		}
+		return tunnel;
+	}
+}