Merge from vscode 31e03b8ffbb218a87e3941f2b63a249f061fe0e4 (#4986)

src/vs/workbench/api/browser/mainThreadWindow.ts

@@ -9,17 +9,22 @@ import { URI, UriComponents } from 'vs/base/common/uri';
 import { IWindowService, IWindowsService } from 'vs/platform/windows/common/windows';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { ExtHostContext, ExtHostWindowShape, IExtHostContext, MainContext, MainThreadWindowShape } from '../common/extHost.protocol';
+import { ITunnelService, RemoteTunnel } from 'vs/platform/remote/common/tunnel';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
 
 @extHostNamedCustomer(MainContext.MainThreadWindow)
 export class MainThreadWindow implements MainThreadWindowShape {
 
 	private readonly proxy: ExtHostWindowShape;
 	private disposables: IDisposable[] = [];
+	private readonly _tunnels = new Map<number, Promise<RemoteTunnel>>();
 
 	constructor(
 		extHostContext: IExtHostContext,
 		@IWindowService private readonly windowService: IWindowService,
-		@IWindowsService private readonly windowsService: IWindowsService
+		@IWindowsService private readonly windowsService: IWindowsService,
+		@ITunnelService private readonly tunnelService: ITunnelService,
+		@IWorkbenchEnvironmentService private readonly environmentService: IWorkbenchEnvironmentService
 	) {
 		this.proxy = extHostContext.getProxy(ExtHostContext.ExtHostWindow);
 
@@ -29,13 +34,54 @@ export class MainThreadWindow implements MainThreadWindowShape {
 
 	dispose(): void {
 		this.disposables = dispose(this.disposables);
+
+		for (const tunnel of this._tunnels.values()) {
+			tunnel.then(tunnel => tunnel.dispose());
+		}
+		this._tunnels.clear();
 	}
 
 	$getWindowVisibility(): Promise<boolean> {
 		return this.windowService.isFocused();
 	}
 
-	$openUri(uri: UriComponents): Promise<boolean> {
-		return this.windowsService.openExternal(URI.revive(uri).toString(true));
+	async $openUri(uriComponent: UriComponents): Promise<boolean> {
+		const uri = URI.revive(uriComponent);
+		if (!!this.environmentService.configuration.remoteAuthority) {
+			if (uri.scheme === 'http' || uri.scheme === 'https') {
+				const port = this.getLocalhostPort(uri);
+				if (typeof port === 'number') {
+					const tunnel = await this.getOrCreateTunnel(port);
+					if (tunnel) {
+						const tunneledUrl = uri.toString().replace(
+							new RegExp(`^${uri.scheme}://localhost:${port}/`),
+							`${uri.scheme}://localhost:${tunnel.tunnelLocalPort}/`);
+						return this.windowsService.openExternal(tunneledUrl);
+					}
+				}
+			}
+		}
+
+		return this.windowsService.openExternal(uri.toString(true));
+	}
+
+	private getLocalhostPort(uri: URI): number | undefined {
+		const match = /^localhost:(\d+)$/.exec(uri.authority);
+		if (match) {
+			return +match[1];
+		}
+		return undefined;
+	}
+
+	private getOrCreateTunnel(remotePort: number): Promise<RemoteTunnel> | undefined {
+		const existing = this._tunnels.get(remotePort);
+		if (existing) {
+			return existing;
+		}
+		const tunnel = this.tunnelService.openTunnel(remotePort);
+		if (tunnel) {
+			this._tunnels.set(remotePort, tunnel);
+		}
+		return tunnel;
 	}
 }