Extract common resource loader logic

src/vs/workbench/contrib/webview/common/resourceLoader.ts

+/*---------------------------------------------------------------------------------------------
+ *  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 { sep } from 'vs/base/common/path';
+import { startsWith } from 'vs/base/common/strings';
+import { URI } from 'vs/base/common/uri';
+import { IFileService } from 'vs/platform/files/common/files';
+import { REMOTE_HOST_SCHEME } from 'vs/platform/remote/common/remoteHosts';
+import { getWebviewContentMimeType } from 'vs/workbench/contrib/webview/common/mimeTypes';
+
+class Success {
+	readonly type = 'success';
+
+	constructor(
+		public readonly data: VSBuffer,
+		public readonly mimeType: string
+	) { }
+}
+
+const Failed = new class { readonly type = 'failed'; };
+const AccessDenied = new class { readonly type = 'access-denied'; };
+
+type LocalResourceResponse = Success | typeof Failed | typeof AccessDenied;
+
+async function resolveContent(
+	fileService: IFileService,
+	resource: URI,
+	mime: string
+): Promise<LocalResourceResponse> {
+	try {
+		const contents = await fileService.readFile(resource);
+		return new Success(contents.value, mime);
+	} catch (err) {
+		console.log(err);
+		return Failed;
+	}
+}
+
+export async function loadLocalResource(
+	requestUri: URI,
+	fileService: IFileService,
+	extensionLocation: URI | undefined,
+	getRoots: () => ReadonlyArray<URI>
+): Promise<LocalResourceResponse> {
+	const requestPath = requestUri.path;
+	const normalizedPath = URI.file(requestPath);
+	for (const root of getRoots()) {
+		if (!startsWith(normalizedPath.fsPath, root.fsPath + sep)) {
+			continue;
+		}
+
+		if (extensionLocation && extensionLocation.scheme === REMOTE_HOST_SCHEME) {
+			const redirectedUri = URI.from({
+				scheme: REMOTE_HOST_SCHEME,
+				authority: extensionLocation.authority,
+				path: '/vscode-resource',
+				query: JSON.stringify({
+					requestResourcePath: requestUri.path
+				})
+			});
+			return resolveContent(fileService, redirectedUri, getWebviewContentMimeType(requestUri));
+		} else {
+			return resolveContent(fileService, normalizedPath, getWebviewContentMimeType(normalizedPath));
+		}
+	}
+
+	return AccessDenied;
+}

src/vs/workbench/contrib/webview/electron-browser/webviewProtocols.ts

@@ -3,27 +3,9 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as electron from 'electron';
-import { sep } from 'vs/base/common/path';
-import { startsWith } from 'vs/base/common/strings';
 import { URI } from 'vs/base/common/uri';
 import { IFileService } from 'vs/platform/files/common/files';
-import { REMOTE_HOST_SCHEME } from 'vs/platform/remote/common/remoteHosts';
-import { getWebviewContentMimeType } from 'vs/workbench/contrib/webview/common/mimeTypes';
-
-type BufferProtocolCallback = (buffer?: Buffer | electron.MimeTypedBuffer | { error: number }) => void;
-
-
-function resolveContent(fileService: IFileService, resource: URI, mime: string, callback: BufferProtocolCallback): void {
-	fileService.readFile(resource).then(contents => {
-		callback({
-			data: Buffer.from(contents.value.buffer),
-			mimeType: mime
-		});
-	}, (err) => {
-		console.log(err);
-		callback({ error: -2 /* FAILED: https://cs.chromium.org/chromium/src/net/base/net_error_list.h */ });
-	});
-}
+import { loadLocalResource } from 'vs/workbench/contrib/webview/common/resourceLoader';
 
 export function registerFileProtocol(
 	contents: electron.WebContents,
@@ -32,33 +14,24 @@ export function registerFileProtocol(
 	extensionLocation: URI | undefined,
 	getRoots: () => ReadonlyArray<URI>
 ) {
-	contents.session.protocol.registerBufferProtocol(protocol, (request, callback: any) => {
-		const requestPath = URI.parse(request.url).path;
-		const normalizedPath = URI.file(requestPath);
-		for (const root of getRoots()) {
-			if (!startsWith(normalizedPath.fsPath, root.fsPath + sep)) {
-				continue;
-			}
-
-			if (extensionLocation && extensionLocation.scheme === REMOTE_HOST_SCHEME) {
-				const requestUri = URI.parse(request.url);
-				const redirectedUri = URI.from({
-					scheme: REMOTE_HOST_SCHEME,
-					authority: extensionLocation.authority,
-					path: '/vscode-resource',
-					query: JSON.stringify({
-						requestResourcePath: requestUri.path
-					})
+	contents.session.protocol.registerBufferProtocol(protocol, async (request, callback: any) => {
+		try {
+			const result = await loadLocalResource(URI.parse(request.url), fileService, extensionLocation, getRoots);
+			if (result.type === 'success') {
+				return callback({
+					data: Buffer.from(result.data.buffer),
+					mimeType: result.mimeType
 				});
-				resolveContent(fileService, redirectedUri, getWebviewContentMimeType(requestUri), callback);
-				return;
-			} else {
-				resolveContent(fileService, normalizedPath, getWebviewContentMimeType(normalizedPath), callback);
-				return;
 			}
+			if (result.type === 'access-denied') {
+				console.error('Webview: Cannot load resource outside of protocol root');
+				return callback({ error: -10 /* ACCESS_DENIED: https://cs.chromium.org/chromium/src/net/base/net_error_list.h */ });
+			}
+		} catch  {
+			// noop
 		}
-		console.error('Webview: Cannot load resource outside of protocol root');
-		callback({ error: -10 /* ACCESS_DENIED: https://cs.chromium.org/chromium/src/net/base/net_error_list.h */ });
+
+		return callback({ error: -2 /* FAILED: https://cs.chromium.org/chromium/src/net/base/net_error_list.h */ });
 	}, (error) => {
 		if (error) {
 			console.error(`Failed to register '${protocol}' protocol`);