Merge from vscode 0f73473c08055054f317c1c94502f7f39fdbb164 (#6892)

* Merge from vscode 0f73473c08055054f317c1c94502f7f39fdbb164

* fix tslinting

src/vs/platform/progress/common/progress.ts

@@ -50,6 +50,7 @@ export interface IProgressOptions {
 	source?: string;
 	total?: number;
 	cancellable?: boolean;
+	buttons?: string[];
 }
 
 export interface IProgressNotificationOptions extends IProgressOptions {

src/vs/platform/remote/common/remoteAgentConnection.ts

@@ -12,6 +12,7 @@ import { Emitter } from 'vs/base/common/event';
 import { RemoteAuthorityResolverError } from 'vs/platform/remote/common/remoteAuthorityResolver';
 import { isPromiseCanceledError } from 'vs/base/common/errors';
 import { ISignService } from 'vs/platform/sign/common/sign';
+import { CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
 
 export const enum ConnectionType {
 	Management = 1,
@@ -245,9 +246,15 @@ export async function connectRemoteAgentTunnel(options: IConnectionOptions, tunn
 	return protocol;
 }
 
-function sleep(seconds: number): Promise<void> {
-	return new Promise<void>((resolve, reject) => {
-		setTimeout(resolve, seconds * 1000);
+function sleep(seconds: number): CancelablePromise<void> {
+	return createCancelablePromise(token => {
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(resolve, seconds * 1000);
+			token.onCancellationRequested(() => {
+				clearTimeout(timeout);
+				resolve();
+			});
+		});
 	});
 }
 
@@ -264,8 +271,13 @@ export class ConnectionLostEvent {
 export class ReconnectionWaitEvent {
 	public readonly type = PersistentConnectionEventType.ReconnectionWait;
 	constructor(
-		public readonly durationSeconds: number
+		public readonly durationSeconds: number,
+		private readonly cancellableTimer: CancelablePromise<void>
 	) { }
+
+	public skipWait(): void {
+		this.cancellableTimer.cancel();
+	}
 }
 export class ReconnectionRunningEvent {
 	public readonly type = PersistentConnectionEventType.ReconnectionRunning;
@@ -330,8 +342,12 @@ abstract class PersistentConnection extends Disposable {
 			attempt++;
 			const waitTime = (attempt < TIMES.length ? TIMES[attempt] : TIMES[TIMES.length - 1]);
 			try {
-				this._onDidStateChange.fire(new ReconnectionWaitEvent(waitTime));
-				await sleep(waitTime);
+				const sleepPromise = sleep(waitTime);
+				this._onDidStateChange.fire(new ReconnectionWaitEvent(waitTime, sleepPromise));
+
+				try {
+					await sleepPromise;
+				} catch { } // User canceled timer
 
 				// connection was lost, let's try to re-establish it
 				this._onDidStateChange.fire(new ReconnectionRunningEvent());

src/vs/platform/url/common/url.ts

@@ -3,8 +3,8 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { URI } from 'vs/base/common/uri';
-import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { URI, UriComponents } from 'vs/base/common/uri';
+import { createDecorator, ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
 import { IDisposable } from 'vs/base/common/lifecycle';
 
 export const IURLService = createDecorator<IURLService>('urlService');
@@ -14,8 +14,17 @@ export interface IURLHandler {
 }
 
 export interface IURLService {
-	_serviceBrand: any;
+
+	_serviceBrand: ServiceIdentifier<any>;
+
+	/**
+	 * Create a URL that can be called to trigger IURLhandlers.
+	 * The URL that gets passed to the IURLHandlers carries over
+	 * any of the provided IURLCreateOption values.
+	 */
+	create(options?: Partial<UriComponents>): URI;
 
 	open(url: URI): Promise<boolean>;
+
 	registerHandler(handler: IURLHandler): IDisposable;
 }

src/vs/platform/url/common/urlService.ts

@@ -4,18 +4,20 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IURLService, IURLHandler } from 'vs/platform/url/common/url';
-import { URI } from 'vs/base/common/uri';
-import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
-import { first } from 'vs/base/common/async';
+import { URI, UriComponents } from 'vs/base/common/uri';
 import { values } from 'vs/base/common/map';
+import { first } from 'vs/base/common/async';
+import { toDisposable, IDisposable, Disposable } from 'vs/base/common/lifecycle';
 import { ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
 
-export class URLService implements IURLService {
+export abstract class AbstractURLService extends Disposable implements IURLService {
 
 	_serviceBrand!: ServiceIdentifier<any>;
 
 	private handlers = new Set<IURLHandler>();
 
+	abstract create(options?: Partial<UriComponents>): URI;
+
 	open(uri: URI): Promise<boolean> {
 		const handlers = values(this.handlers);
 		return first(handlers.map(h => () => h.handleURL(uri)), undefined, false).then(val => val || false);

src/vs/platform/url/electron-browser/urlService.ts

@@ -1,45 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { IURLService, IURLHandler } from 'vs/platform/url/common/url';
-import { URI } from 'vs/base/common/uri';
-import { IMainProcessService } from 'vs/platform/ipc/electron-browser/mainProcessService';
-import { URLServiceChannelClient, URLHandlerChannel } from 'vs/platform/url/node/urlIpc';
-import { URLService } from 'vs/platform/url/common/urlService';
-import { IOpenerService } from 'vs/platform/opener/common/opener';
-import product from 'vs/platform/product/node/product';
-
-export class RelayURLService extends URLService implements IURLHandler {
-
-	private urlService: IURLService;
-
-	constructor(
-		@IMainProcessService mainProcessService: IMainProcessService,
-		@IOpenerService openerService: IOpenerService
-	) {
-		super();
-
-		this.urlService = new URLServiceChannelClient(mainProcessService.getChannel('url'));
-
-		mainProcessService.registerChannel('urlHandler', new URLHandlerChannel(this));
-		openerService.registerOpener(this);
-	}
-
-	async open(resource: URI, options?: { openToSide?: boolean, openExternal?: boolean }): Promise<boolean> {
-		if (options && options.openExternal) {
-			return false;
-		}
-
-		if (resource.scheme !== product.urlProtocol) {
-			return false;
-		}
-
-		return await this.urlService.open(resource);
-	}
-
-	handleURL(uri: URI): Promise<boolean> {
-		return super.open(uri);
-	}
-}

src/vs/platform/url/node/urlIpc.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
-import { URI } from 'vs/base/common/uri';
+import { URI, UriComponents } from 'vs/base/common/uri';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { Event } from 'vs/base/common/event';
 import { IURLService, IURLHandler } from 'vs/platform/url/common/url';
@@ -39,6 +39,10 @@ export class URLServiceChannelClient implements IURLService {
 	registerHandler(handler: IURLHandler): IDisposable {
 		throw new Error('Not implemented.');
 	}
+
+	create(_options?: Partial<UriComponents>): URI {
+		throw new Error('Method not implemented.');
+	}
 }
 
 export class URLHandlerChannel implements IServerChannel {

src/vs/platform/url/node/urlService.ts

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { URI, UriComponents } from 'vs/base/common/uri';
+import product from 'vs/platform/product/node/product';
+import { AbstractURLService } from 'vs/platform/url/common/urlService';
+
+export class URLService extends AbstractURLService {
+
+	create(options?: Partial<UriComponents>): URI {
+		const { authority, path, query, fragment } = options ? options : { authority: undefined, path: undefined, query: undefined, fragment: undefined };
+
+		return URI.from({ scheme: product.urlProtocol, authority, path, query, fragment });
+	}
+}