Merge remote-tracking branch 'origin/master' into aeschli/isEqualCaseSensitiveForNonFIle

extensions/markdown-basics/syntaxes/markdown.tmLanguage.json

@@ -716,7 +716,7 @@
 				{
 					"begin": "(^|\\G)(\\s*)(.*)",
 					"while": "(^|\\G)(?!\\s*([`~]{3,})\\s*$)",
-					"contentName": "meta.embedded.block.cpp",
+					"contentName": "meta.embedded.block.cpp source.cpp",
 					"patterns": [
 						{
 							"include": "source.cpp"

src/vs/base/browser/dom.ts

@@ -1199,7 +1199,7 @@ export function asDomUri(uri: URI): URI {
 	if (Schemas.vscodeRemote === uri.scheme) {
 		// rewrite vscode-remote-uris to uris of the window location
 		// so that they can be intercepted by the service worker
-		return _location.with({ path: '/vscode-resources/fetch', query: uri.toString() });
+		return _location.with({ path: '/vscode-resources/fetch', query: JSON.stringify({ u: uri.toJSON(), i: 1 }) });
 	}
 	return uri;
 }

src/vs/workbench/contrib/resources/browser/resourceServiceWorker.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { URI } from 'vs/base/common/uri';
+import { URI, UriComponents } from 'vs/base/common/uri';
 import { generateUuid } from 'vs/base/common/uuid';
 import { getMediaMime } from 'vs/base/common/mime';
 
@@ -78,13 +78,13 @@ async function respondWithResource(event: FetchEvent, uri: URI): Promise<Respons
 	return new Promise<Response>(resolve => {
 
 		const token = generateUuid();
-		const resourceUri = URI.parse(uri.query);
+		const query: { u: UriComponents, i: number } = JSON.parse(uri.query);
 
 		_pendingFetch.set(token, async (data: ArrayBuffer, isExtensionResource: boolean) => {
 
 			const res = new Response(data, {
 				status: 200,
-				headers: { 'Content-Type': getMediaMime(resourceUri.path) || 'text/plain' }
+				headers: { 'Content-Type': getMediaMime(query.u.path) || 'text/plain' }
 			});
 
 			if (isExtensionResource) {
@@ -97,7 +97,7 @@ async function respondWithResource(event: FetchEvent, uri: URI): Promise<Respons
 		});
 
 		self.clients.get(event.clientId).then(client => {
-			client.postMessage({ uri: resourceUri, token });
+			client.postMessage({ uri: query.u, token });
 		});
 	});
 }

src/vs/workbench/contrib/resources/browser/resourceServiceWorkerClient.ts

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IFileService } from 'vs/platform/files/common/files';
-import { DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
 import { Registry } from 'vs/platform/registry/common/platform';
 import { IWorkbenchContributionsRegistry, Extensions } from 'vs/workbench/common/contributions';
@@ -13,58 +12,78 @@ import { IExtensionService } from 'vs/workbench/services/extensions/common/exten
 import { isEqualOrParent } from 'vs/base/common/resources';
 import { ILogService } from 'vs/platform/log/common/log';
 
-class ResourceServiceWorker {
+// load and start service worker as soon as this file
+// is being loaded and later, when services are ready,
+// claim this service worker so that messages can be
+// replied to
+const _serviceWorker = new class ServiceWorkerStarter {
+
+	private static _url = require.toUrl('./resourceServiceWorkerMain.js');
+
+	private _beforeReadyEvents: ExtendableMessageEvent[] = [];
+	private _messageHandler?: (event: ExtendableMessageEvent) => void;
+
+	constructor() {
+		navigator.serviceWorker.register(ServiceWorkerStarter._url, { scope: '/' }).then(reg => {
+			// console.debug('SW#reg', reg);
+			return navigator.serviceWorker.ready;
+		}).then(() => {
+			// console.debug('SW#init');
+		}).catch(err => {
+			console.error('SW#init', err);
+		});
+
+		const handleMessage = (event: ExtendableMessageEvent) => {
+			if (!this._messageHandler) {
+				this._beforeReadyEvents.push(event);
+				console.debug('SW#buffered', event.data);
+			} else {
+				this._messageHandler(event);
+			}
+		};
+
+		navigator.serviceWorker.addEventListener('message', e => handleMessage(e as ExtendableMessageEvent));
+	}
+
+	dispose(): void {
+		// when to dispose?
+	}
 
-	private readonly _disposables = new DisposableStore();
+	claim(handler: (event: ExtendableMessageEvent) => void): void {
+		this._messageHandler = handler;
+		this._beforeReadyEvents.forEach(this._messageHandler);
+	}
+};
+
+class ResourceServiceWorker {
 
 	constructor(
 		@IFileService private readonly _fileService: IFileService,
 		@IExtensionService private readonly _extensionService: IExtensionService,
 		@ILogService private readonly _logService: ILogService,
 	) {
-		this._initServiceWorker();
-		this._initFetchHandler();
+		_serviceWorker.claim(e => this._handleMessage(e));
 	}
 
-	dispose(): void {
-		this._disposables.dispose();
-	}
+	private _handleMessage(event: ExtendableMessageEvent): void {
+		this._logService.trace('SW#fetch', event.data.uri);
 
-	private _initServiceWorker(): void {
-		const url = require.toUrl('./resourceServiceWorkerMain.js');
-		navigator.serviceWorker.register(url, { scope: '/' }).then(reg => {
-			return navigator.serviceWorker.ready;
-		}).then(() => {
-			this._logService.trace('SW#init', navigator.serviceWorker.controller);
-		}).catch(err => {
-			this._logService.error('SW#init', err);
+		const uri = URI.revive(event.data.uri);
+		Promise.all([
+			this._fileService.readFile(uri),
+			this._isExtensionResource(uri)
+		]).then(([file, isExtensionResource]) => {
+			if (!event.source) {
+				return;
+			}
+			event.source.postMessage({
+				token: event.data.token,
+				data: file.value.buffer.buffer,
+				isExtensionResource
+			}, [file.value.buffer.buffer]);
 		});
 	}
 
-	private _initFetchHandler(): void {
-
-		const fetchListener: (this: ServiceWorkerContainer, ev: ExtendableMessageEvent) => void = event => {
-			this._logService.trace('SW#fetch', event.data.uri);
-
-			const uri = URI.revive(event.data.uri);
-			Promise.all([
-				this._fileService.readFile(uri),
-				this._isExtensionResource(uri)
-			]).then(([file, isExtensionResource]) => {
-				if (!event.source) {
-					return;
-				}
-				event.source.postMessage({
-					token: event.data.token,
-					data: file.value.buffer.buffer,
-					isExtensionResource
-				}, [file.value.buffer.buffer]);
-			});
-		};
-		navigator.serviceWorker.addEventListener('message', fetchListener);
-		this._disposables.add(toDisposable(() => navigator.serviceWorker.removeEventListener('message', fetchListener)));
-	}
-
 	private async _isExtensionResource(uri: URI): Promise<boolean> {
 		for (const ext of await this._extensionService.getExtensions()) {
 			if (isEqualOrParent(uri, ext.extensionLocation)) {
@@ -77,7 +96,7 @@ class ResourceServiceWorker {
 
 Registry.as<IWorkbenchContributionsRegistry>(Extensions.Workbench).registerWorkbenchContribution(
 	ResourceServiceWorker,
-	LifecyclePhase.Starting
+	LifecyclePhase.Ready
 );
 
 

src/vs/workbench/services/dialogs/browser/remoteFileDialog.ts

@@ -215,7 +215,7 @@ export class RemoteFileDialog {
 			this.filePickBox.autoFocusOnList = false;
 			this.filePickBox.ignoreFocusOut = true;
 			this.filePickBox.ok = true;
-			if (this.options && this.options.availableFileSystems && (this.options.availableFileSystems.length > 1)) {
+			if (this.options && this.options.availableFileSystems && (this.options.availableFileSystems.length > 1) && (this.options.availableFileSystems.indexOf(Schemas.file) > -1)) {
 				this.filePickBox.customButton = true;
 				this.filePickBox.customLabel = nls.localize('remoteFileDialog.local', 'Show Local');
 				let action;