further renames

src/vs/base/browser/dom.ts

@@ -13,7 +13,7 @@ import { Emitter, Event } from 'vs/base/common/event';
 import { Disposable, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import * as platform from 'vs/base/common/platform';
 import { URI } from 'vs/base/common/uri';
-import { Schemas, LocalFileAccess, RemoteAuthorities } from 'vs/base/common/network';
+import { Schemas, FileAccess, RemoteAuthorities } from 'vs/base/common/network';
 import { BrowserFeatures } from 'vs/base/browser/canIUse';
 
 export function clearNode(node: HTMLElement): void {
@@ -1224,17 +1224,11 @@ export function asDomUri(uri: URI): URI {
 		return uri;
 	}
 
-	// Remote support
-	if (Schemas.vscodeRemote === uri.scheme) {
+	if (uri.scheme === Schemas.vscodeRemote) {
 		return RemoteAuthorities.rewrite(uri);
 	}
 
-	// Local access support
-	if (platform.isNative && Schemas.file === uri.scheme) {
-		return LocalFileAccess.asCodeUri(uri);
-	}
-
-	return uri;
+	return FileAccess.asBrowserUri(uri);
 }
 
 /**

src/vs/base/common/network.ts

@@ -5,7 +5,6 @@
 
 import { URI } from 'vs/base/common/uri';
 import * as platform from 'vs/base/common/platform';
-import { getUriFromAmdModule } from 'vs/base/common/amd';
 
 export namespace Schemas {
 
@@ -137,29 +136,34 @@ class RemoteAuthoritiesImpl {
 
 export const RemoteAuthorities = new RemoteAuthoritiesImpl();
 
-class LocalFileAccessImpl {
+class FileAccessImpl {
 
 	private readonly FALLBACK_AUTHORITY = 'vscode-app';
 
 	/**
-	 * Returns a `vscode-file` URI to use in contexts where
-	 * the browser is responsible for loading (e.g. fetch())
+	 * Returns a URI to use in contexts where the browser is responsible
+	 * for loading (e.g. fetch()) or when used within the DOM.
 	 */
-	asCodeUri(uri: URI): URI;
-	asCodeUri(moduleId: string, requireFn: typeof require): URI;
-	asCodeUri(uriOrModule: URI | string, requireFn?: typeof require): URI {
+	asBrowserUri(uri: URI): URI;
+	asBrowserUri(moduleId: string, requireFn: typeof require): URI;
+	asBrowserUri(uriOrModule: URI | string, requireFn?: typeof require): URI {
 		const uri = this.toUri(uriOrModule, requireFn);
 
-		return uri.with({
-			scheme: Schemas.vscodeFileResource,
-			// We need to provide an authority here so that it can serve
-			// as origin for network and loading matters in chromium.
-			// If the URI is not coming with an authority already, we
-			// add our own
-			authority: uri.authority || this.FALLBACK_AUTHORITY,
-			query: null,
-			fragment: null
-		});
+		// Only convert the URI if we are in a native context and it has `file:` scheme
+		if (platform.isNative && uri.scheme === Schemas.file) {
+			return uri.with({
+				scheme: Schemas.vscodeFileResource,
+				// We need to provide an authority here so that it can serve
+				// as origin for network and loading matters in chromium.
+				// If the URI is not coming with an authority already, we
+				// add our own
+				authority: uri.authority || this.FALLBACK_AUTHORITY,
+				query: null,
+				fragment: null
+			});
+		}
+
+		return uri;
 	}
 
 	/**
@@ -171,24 +175,29 @@ class LocalFileAccessImpl {
 	asFileUri(uriOrModule: URI | string, requireFn?: typeof require): URI {
 		const uri = this.toUri(uriOrModule, requireFn);
 
-		return uri.with({
-			scheme: Schemas.file,
-			// Only preserve the `authority` if it is different from
-			// our fallback authority. This ensures we properly preserve
-			// Windows UNC paths that come with their own authority.
-			authority: uri.authority !== this.FALLBACK_AUTHORITY ? uri.authority : null,
-			query: null,
-			fragment: null
-		});
+		// Only convert the URI if it is not already `file:` scheme
+		if (uri.scheme !== Schemas.file) {
+			return uri.with({
+				scheme: Schemas.file,
+				// Only preserve the `authority` if it is different from
+				// our fallback authority. This ensures we properly preserve
+				// Windows UNC paths that come with their own authority.
+				authority: uri.authority !== this.FALLBACK_AUTHORITY ? uri.authority : null,
+				query: null,
+				fragment: null
+			});
+		}
+
+		return uri;
 	}
 
 	private toUri(uriOrModule: URI | string, requireFn?: typeof require): URI {
 		if (URI.isUri(uriOrModule)) {
 			return uriOrModule;
 		}
 
-		return getUriFromAmdModule(requireFn!, uriOrModule);
+		return URI.parse(requireFn!.toUrl(uriOrModule));
 	}
 }
 
-export const LocalFileAccess = new LocalFileAccessImpl();
+export const FileAccess = new FileAccessImpl();

src/vs/base/test/common/network.test.ts

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { URI } from 'vs/base/common/uri';
+import { FileAccess, Schemas } from 'vs/base/common/network';
+import { isEqual } from 'vs/base/common/resources';
+import { isWeb } from 'vs/base/common/platform';
+
+suite('network', () => {
+
+	(isWeb ? test.skip : test)('FileAccess: URI (native)', () => {
+
+		// asCodeUri() & asFileUri(): simple, without authority
+		let originalFileUri = URI.file('network.test.ts');
+		let browserUri = FileAccess.asBrowserUri(originalFileUri);
+		assert.ok(browserUri.authority.length > 0);
+		let fileUri = FileAccess.asFileUri(browserUri);
+		assert.equal(fileUri.authority.length, 0);
+		assert(isEqual(originalFileUri, fileUri));
+
+		// asCodeUri() & asFileUri(): with authority
+		originalFileUri = URI.file('network.test.ts').with({ authority: 'test-authority' });
+		browserUri = FileAccess.asBrowserUri(originalFileUri);
+		assert.equal(browserUri.authority, originalFileUri.authority);
+		fileUri = FileAccess.asFileUri(browserUri);
+		assert(isEqual(originalFileUri, fileUri));
+	});
+
+	(isWeb ? test.skip : test)('FileAccess: moduleId (native)', () => {
+		const browserUri = FileAccess.asBrowserUri('vs/base/test/node/network.test', require);
+		assert.equal(browserUri.scheme, Schemas.vscodeFileResource);
+
+		const fileUri = FileAccess.asFileUri('vs/base/test/node/network.test', require);
+		assert.equal(fileUri.scheme, Schemas.file);
+	});
+
+	(isWeb ? test.skip : test)('FileAccess: query and fragment is dropped (native)', () => {
+		let originalFileUri = URI.file('network.test.ts').with({ query: 'foo=bar', fragment: 'something' });
+		let browserUri = FileAccess.asBrowserUri(originalFileUri);
+		assert.equal(browserUri.query, '');
+		assert.equal(browserUri.fragment, '');
+	});
+
+	(isWeb ? test.skip : test)('FileAccess: query and fragment is kept if URI is already of same scheme (native)', () => {
+		let originalFileUri = URI.file('network.test.ts').with({ query: 'foo=bar', fragment: 'something' });
+		let browserUri = FileAccess.asBrowserUri(originalFileUri.with({ scheme: Schemas.vscodeFileResource }));
+		assert.equal(browserUri.query, 'foo=bar');
+		assert.equal(browserUri.fragment, 'something');
+
+		let fileUri = FileAccess.asFileUri(originalFileUri);
+		assert.equal(fileUri.query, 'foo=bar');
+		assert.equal(fileUri.fragment, 'something');
+	});
+
+	(isWeb ? test.skip : test)('FileAccess: web', () => {
+		const originalHttpsUri = URI.file('network.test.ts').with({ scheme: 'https' });
+		const browserUri = FileAccess.asBrowserUri(originalHttpsUri);
+		assert.equal(originalHttpsUri.toString(), browserUri.toString());
+	});
+});

src/vs/code/electron-main/auth.ts

@@ -6,9 +6,8 @@
 import { localize } from 'vs/nls';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { Event } from 'vs/base/common/event';
-import { LocalFileAccess } from 'vs/base/common/network';
+import { FileAccess } from 'vs/base/common/network';
 import { BrowserWindow, BrowserWindowConstructorOptions, app, AuthInfo, WebContents, Event as ElectronEvent } from 'electron';
-import { getPathFromAmdModule } from 'vs/base/common/amd';
 
 type LoginEvent = {
 	event: ElectronEvent;
@@ -60,7 +59,7 @@ export class ProxyAuthHandler extends Disposable {
 			show: true,
 			title: 'VS Code',
 			webPreferences: {
-				preload: getPathFromAmdModule(require, 'vs/base/parts/sandbox/electron-browser/preload.js'),
+				preload: FileAccess.asFileUri('vs/base/parts/sandbox/electron-browser/preload.js', require).fsPath,
 				sandbox: true,
 				contextIsolation: true,
 				enableWebSQL: false,
@@ -77,7 +76,7 @@ export class ProxyAuthHandler extends Disposable {
 		}
 
 		const win = new BrowserWindow(opts);
-		const windowUrl = LocalFileAccess.asCodeUri('vs/code/electron-sandbox/proxy/auth.html', require);
+		const windowUrl = FileAccess.asBrowserUri('vs/code/electron-sandbox/proxy/auth.html', require);
 		const proxyUrl = `${authInfo.host}:${authInfo.port}`;
 		const title = localize('authRequire', "Proxy Authentication Required");
 		const message = localize('proxyauth', "The proxy {0} requires authentication.", proxyUrl);

src/vs/code/electron-main/protocol.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
-import { LocalFileAccess, Schemas } from 'vs/base/common/network';
+import { FileAccess, Schemas } from 'vs/base/common/network';
 import { URI } from 'vs/base/common/uri';
 import { INativeEnvironmentService } from 'vs/platform/environment/common/environment';
 import { session } from 'electron';
@@ -57,14 +57,14 @@ export class FileProtocolHandler extends Disposable {
 		// Restore the `vscode-file` URI to a `file` URI so that we can
 		// ensure the root is valid and properly tell Chrome where the
 		// resource is at.
-		const restoredUri = LocalFileAccess.restore(uri, false /* includeQuery */);
-		if (validRoots.some(validRoot => extUriBiasedIgnorePathCase.isEqualOrParent(restoredUri, validRoot))) {
+		const fileUri = FileAccess.asFileUri(uri);
+		if (validRoots.some(validRoot => extUriBiasedIgnorePathCase.isEqualOrParent(fileUri, validRoot))) {
 			return callback({
-				path: restoredUri.fsPath
+				path: fileUri.fsPath
 			});
 		}
 
-		this.logService.error(`${Schemas.vscodeFileResource}: Refused to load resource ${restoredUri.fsPath}}`);
+		this.logService.error(`${Schemas.vscodeFileResource}: Refused to load resource ${fileUri.fsPath}}`);
 		callback({ error: -3 /* ABORTED */ });
 	}
 }

src/vs/code/electron-main/sharedProcess.ts

@@ -13,8 +13,7 @@ import { ILifecycleMainService } from 'vs/platform/lifecycle/electron-main/lifec
 import { IThemeMainService } from 'vs/platform/theme/electron-main/themeMainService';
 import { toDisposable, DisposableStore } from 'vs/base/common/lifecycle';
 import { Event } from 'vs/base/common/event';
-import { LocalFileAccess } from 'vs/base/common/network';
-import { getPathFromAmdModule } from 'vs/base/common/amd';
+import { FileAccess } from 'vs/base/common/network';
 
 export class SharedProcess implements ISharedProcess {
 
@@ -42,7 +41,7 @@ export class SharedProcess implements ISharedProcess {
 			show: false,
 			backgroundColor: this.themeMainService.getBackgroundColor(),
 			webPreferences: {
-				preload: getPathFromAmdModule(require, 'vs/base/parts/sandbox/electron-browser/preload.js'),
+				preload: FileAccess.asFileUri('vs/base/parts/sandbox/electron-browser/preload.js', require).fsPath,
 				v8CacheOptions: this.environmentService.v8CacheOptions,
 				nodeIntegration: true,
 				enableWebSQL: false,
@@ -62,8 +61,8 @@ export class SharedProcess implements ISharedProcess {
 			windowId: this.window.id
 		};
 
-		const windowUrl = LocalFileAccess
-			.asCodeUri('vs/code/electron-browser/sharedProcess/sharedProcess.html', require)
+		const windowUrl = FileAccess
+			.asBrowserUri('vs/code/electron-browser/sharedProcess/sharedProcess.html', require)
 			.with({ query: `config=${encodeURIComponent(JSON.stringify(config))}` });
 		this.window.loadURL(windowUrl.toString(true));
 

src/vs/code/electron-main/window.ts

@@ -34,9 +34,8 @@ import { ThemeIcon } from 'vs/platform/theme/common/themeService';
 import { ILifecycleMainService } from 'vs/platform/lifecycle/electron-main/lifecycleMainService';
 import { IStorageMainService } from 'vs/platform/storage/node/storageMainService';
 import { IFileService } from 'vs/platform/files/common/files';
-import { LocalFileAccess, Schemas } from 'vs/base/common/network';
+import { FileAccess, Schemas } from 'vs/base/common/network';
 import { ColorScheme } from 'vs/platform/theme/common/theme';
-import { getPathFromAmdModule } from 'vs/base/common/amd';
 
 export interface IWindowCreationOptions {
 	state: IWindowState;
@@ -168,7 +167,7 @@ export class CodeWindow extends Disposable implements ICodeWindow {
 				show: !isFullscreenOrMaximized,
 				title: product.nameLong,
 				webPreferences: {
-					preload: getPathFromAmdModule(require, 'vs/base/parts/sandbox/electron-browser/preload.js'),
+					preload: FileAccess.asFileUri('vs/base/parts/sandbox/electron-browser/preload.js', require).fsPath,
 					v8CacheOptions: this.environmentService.v8CacheOptions,
 					enableWebSQL: false,
 					enableRemoteModule: false,
@@ -840,8 +839,8 @@ export class CodeWindow extends Disposable implements ICodeWindow {
 			workbench = 'vs/code/electron-browser/workbench/workbench.html';
 		}
 
-		return LocalFileAccess
-			.asCodeUri(workbench, require)
+		return FileAccess
+			.asBrowserUri(workbench, require)
 			.with({ query: `config=${encodeURIComponent(JSON.stringify(config))}` })
 			.toString(true);
 	}

src/vs/platform/issue/electron-main/issueMainService.ts

@@ -18,10 +18,9 @@ import { ILogService } from 'vs/platform/log/common/log';
 import { IWindowState } from 'vs/platform/windows/electron-main/windows';
 import { listProcesses } from 'vs/base/node/ps';
 import { IDialogMainService } from 'vs/platform/dialogs/electron-main/dialogs';
-import { getPathFromAmdModule } from 'vs/base/common/amd';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { zoomLevelToZoomFactor } from 'vs/platform/windows/common/windows';
-import { LocalFileAccess } from 'vs/base/common/network';
+import { FileAccess } from 'vs/base/common/network';
 
 const DEFAULT_BACKGROUND_COLOR = '#1E1E1E';
 
@@ -196,7 +195,7 @@ export class IssueMainService implements ICommonIssueService {
 						title: localize('issueReporter', "Issue Reporter"),
 						backgroundColor: data.styles.backgroundColor || DEFAULT_BACKGROUND_COLOR,
 						webPreferences: {
-							preload: getPathFromAmdModule(require, 'vs/base/parts/sandbox/electron-browser/preload.js'),
+							preload: FileAccess.asFileUri('vs/base/parts/sandbox/electron-browser/preload.js', require).fsPath,
 							v8CacheOptions: this.environmentService.v8CacheOptions,
 							enableWebSQL: false,
 							enableRemoteModule: false,
@@ -263,7 +262,7 @@ export class IssueMainService implements ICommonIssueService {
 						backgroundColor: data.styles.backgroundColor,
 						title: localize('processExplorer', "Process Explorer"),
 						webPreferences: {
-							preload: getPathFromAmdModule(require, 'vs/base/parts/sandbox/electron-browser/preload.js'),
+							preload: FileAccess.asFileUri('vs/base/parts/sandbox/electron-browser/preload.js', require).fsPath,
 							v8CacheOptions: this.environmentService.v8CacheOptions,
 							enableWebSQL: false,
 							enableRemoteModule: false,
@@ -452,8 +451,8 @@ function toWindowUrl<T>(modulePathToHtml: string, windowConfiguration: T): strin
 		}
 	}
 
-	return LocalFileAccess
-		.asCodeUri(modulePathToHtml, require)
+	return FileAccess
+		.asBrowserUri(modulePathToHtml, require)
 		.with({ query: `config=${encodeURIComponent(JSON.stringify(config))}` })
 		.toString(true);
 }