SQL Operations Studio Public Preview 1 (0.23) release source code

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

@@ -0,0 +1,421 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { app, ipcMain as ipc, BrowserWindow } from 'electron';
+import * as platform from 'vs/base/common/platform';
+import { WindowsManager } from 'vs/code/electron-main/windows';
+import { IWindowsService, OpenContext } from 'vs/platform/windows/common/windows';
+import { WindowsChannel } from 'vs/platform/windows/common/windowsIpc';
+import { WindowsService } from 'vs/platform/windows/electron-main/windowsService';
+import { ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
+import { CodeMenu } from 'vs/code/electron-main/menus';
+import { getShellEnvironment } from 'vs/code/node/shellEnv';
+import { IUpdateService } from 'vs/platform/update/common/update';
+import { UpdateChannel } from 'vs/platform/update/common/updateIpc';
+import { UpdateService } from 'vs/platform/update/electron-main/updateService';
+import { Server as ElectronIPCServer } from 'vs/base/parts/ipc/electron-main/ipc.electron-main';
+import { Server, connect, Client } from 'vs/base/parts/ipc/node/ipc.net';
+import { SharedProcess } from 'vs/code/electron-main/sharedProcess';
+import { Mutex } from 'windows-mutex';
+import { LaunchService, LaunchChannel, ILaunchService } from './launch';
+import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
+import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IStorageService } from 'vs/platform/storage/node/storage';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { IURLService } from 'vs/platform/url/common/url';
+import { URLChannel } from 'vs/platform/url/common/urlIpc';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils';
+import { ITelemetryAppenderChannel, TelemetryAppenderClient } from 'vs/platform/telemetry/common/telemetryIpc';
+import { TelemetryService, ITelemetryServiceConfig } from 'vs/platform/telemetry/common/telemetryService';
+import { ICredentialsService } from 'vs/platform/credentials/common/credentials';
+import { CredentialsService } from 'vs/platform/credentials/node/credentialsService';
+import { CredentialsChannel } from 'vs/platform/credentials/node/credentialsIpc';
+import { resolveCommonProperties, machineIdStorageKey, machineIdIpcChannel } from 'vs/platform/telemetry/node/commonProperties';
+import { getDelayedChannel } from 'vs/base/parts/ipc/common/ipc';
+import product from 'vs/platform/node/product';
+import pkg from 'vs/platform/node/package';
+import { ProxyAuthHandler } from './auth';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { ConfigurationService } from 'vs/platform/configuration/node/configurationService';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { IWindowsMainService } from 'vs/platform/windows/electron-main/windows';
+import { IHistoryMainService } from 'vs/platform/history/common/history';
+import { isUndefinedOrNull } from 'vs/base/common/types';
+import { CodeWindow } from 'vs/code/electron-main/window';
+import { KeyboardLayoutMonitor } from 'vs/code/electron-main/keyboard';
+import URI from 'vs/base/common/uri';
+import { WorkspacesChannel } from 'vs/platform/workspaces/common/workspacesIpc';
+import { IWorkspacesMainService } from 'vs/platform/workspaces/common/workspaces';
+import { dirname, join } from 'path';
+import { touch } from 'vs/base/node/pfs';
+
+// {{SQL CARBON EDIT}}
+import { ProxyOAuthHandler } from 'sql/code/electron-main/oauth';
+
+export class CodeApplication {
+
+	private static APP_ICON_REFRESH_KEY = 'macOSAppIconRefresh';
+
+	private toDispose: IDisposable[];
+	private windowsMainService: IWindowsMainService;
+
+	private electronIpcServer: ElectronIPCServer;
+
+	private sharedProcess: SharedProcess;
+	private sharedProcessClient: TPromise<Client>;
+
+	constructor(
+		private mainIpcServer: Server,
+		private userEnv: platform.IProcessEnvironment,
+		@IInstantiationService private instantiationService: IInstantiationService,
+		@ILogService private logService: ILogService,
+		@IEnvironmentService private environmentService: IEnvironmentService,
+		@ILifecycleService private lifecycleService: ILifecycleService,
+		@IConfigurationService private configurationService: ConfigurationService<any>,
+		@IStorageService private storageService: IStorageService,
+		@IHistoryMainService private historyService: IHistoryMainService
+	) {
+		this.toDispose = [mainIpcServer, configurationService];
+
+		this.registerListeners();
+	}
+
+	private registerListeners(): void {
+
+		// We handle uncaught exceptions here to prevent electron from opening a dialog to the user
+		process.on('uncaughtException', (err: any) => {
+			if (err) {
+
+				// take only the message and stack property
+				const friendlyError = {
+					message: err.message,
+					stack: err.stack
+				};
+
+				// handle on client side
+				if (this.windowsMainService) {
+					this.windowsMainService.sendToFocused('vscode:reportError', JSON.stringify(friendlyError));
+				}
+			}
+
+			this.logService.error(`[uncaught exception in main]: ${err}`);
+			if (err.stack) {
+				this.logService.error(err.stack);
+			}
+		});
+
+		app.on('will-quit', () => {
+			this.logService.log('App#will-quit: disposing resources');
+
+			this.dispose();
+		});
+
+		app.on('accessibility-support-changed', (event: Event, accessibilitySupportEnabled: boolean) => {
+			if (this.windowsMainService) {
+				this.windowsMainService.sendToAll('vscode:accessibilitySupportChanged', accessibilitySupportEnabled);
+			}
+		});
+
+		app.on('activate', (event: Event, hasVisibleWindows: boolean) => {
+			this.logService.log('App#activate');
+
+			// Mac only event: open new window when we get activated
+			if (!hasVisibleWindows && this.windowsMainService) {
+				this.windowsMainService.openNewWindow(OpenContext.DOCK);
+			}
+		});
+
+		const isValidWebviewSource = (source: string) =>
+			!source || (URI.parse(source.toLowerCase()).toString() as any).startsWith(URI.file(this.environmentService.appRoot.toLowerCase()).toString());
+
+		app.on('web-contents-created', (event, contents) => {
+			contents.on('will-attach-webview', (event, webPreferences, params) => {
+				delete webPreferences.preload;
+				webPreferences.nodeIntegration = false;
+
+				// Verify URLs being loaded
+				if (isValidWebviewSource(params.src) && isValidWebviewSource(webPreferences.preloadURL)) {
+					return;
+				}
+
+				// Otherwise prevent loading
+				this.logService.error('webContents#web-contents-created: Prevented webview attach');
+				event.preventDefault();
+			});
+
+			contents.on('will-navigate', event => {
+				this.logService.error('webContents#will-navigate: Prevented webcontent navigation');
+				event.preventDefault();
+			});
+		});
+
+		let macOpenFiles: string[] = [];
+		let runningTimeout: number = null;
+		app.on('open-file', (event: Event, path: string) => {
+			this.logService.log('App#open-file: ', path);
+			event.preventDefault();
+
+			// Keep in array because more might come!
+			macOpenFiles.push(path);
+
+			// Clear previous handler if any
+			if (runningTimeout !== null) {
+				clearTimeout(runningTimeout);
+				runningTimeout = null;
+			}
+
+			// Handle paths delayed in case more are coming!
+			runningTimeout = setTimeout(() => {
+				if (this.windowsMainService) {
+					this.windowsMainService.open({
+						context: OpenContext.DOCK /* can also be opening from finder while app is running */,
+						cli: this.environmentService.args,
+						pathsToOpen: macOpenFiles,
+						preferNewWindow: true /* dropping on the dock or opening from finder prefers to open in a new window */
+					});
+					macOpenFiles = [];
+					runningTimeout = null;
+				}
+			}, 100);
+		});
+
+		app.on('new-window-for-tab', () => {
+			this.windowsMainService.openNewWindow(OpenContext.DESKTOP); //macOS native tab "+" button
+		});
+
+		ipc.on('vscode:exit', (event, code: number) => {
+			this.logService.log('IPC#vscode:exit', code);
+
+			this.dispose();
+			this.lifecycleService.kill(code);
+		});
+
+		ipc.on(machineIdIpcChannel, (event, machineId: string) => {
+			this.logService.log('IPC#vscode-machineId');
+			this.storageService.setItem(machineIdStorageKey, machineId);
+		});
+
+		ipc.on('vscode:fetchShellEnv', (event, windowId) => {
+			const { webContents } = BrowserWindow.fromId(windowId);
+			getShellEnvironment().then(shellEnv => {
+				if (!webContents.isDestroyed()) {
+					webContents.send('vscode:acceptShellEnv', shellEnv);
+				}
+			}, err => {
+				if (!webContents.isDestroyed()) {
+					webContents.send('vscode:acceptShellEnv', {});
+				}
+
+				this.logService.error('Error fetching shell env', err);
+			});
+		});
+
+		ipc.on('vscode:broadcast', (event, windowId: number, broadcast: { channel: string; payload: any; }) => {
+			if (this.windowsMainService && broadcast.channel && !isUndefinedOrNull(broadcast.payload)) {
+				this.logService.log('IPC#vscode:broadcast', broadcast.channel, broadcast.payload);
+
+				// Handle specific events on main side
+				this.onBroadcast(broadcast.channel, broadcast.payload);
+
+				// Send to all windows (except sender window)
+				this.windowsMainService.sendToAll('vscode:broadcast', broadcast, [windowId]);
+			}
+		});
+
+		// Keyboard layout changes
+		KeyboardLayoutMonitor.INSTANCE.onDidChangeKeyboardLayout(isISOKeyboard => {
+			if (this.windowsMainService) {
+				this.windowsMainService.sendToAll('vscode:keyboardLayoutChanged', isISOKeyboard);
+			}
+		});
+	}
+
+	private onBroadcast(event: string, payload: any): void {
+
+		// Theme changes
+		if (event === 'vscode:changeColorTheme' && typeof payload === 'string') {
+			let data = JSON.parse(payload);
+
+			this.storageService.setItem(CodeWindow.themeStorageKey, data.id);
+			this.storageService.setItem(CodeWindow.themeBackgroundStorageKey, data.background);
+		}
+	}
+
+	public startup(): void {
+		this.logService.log('Starting VS Code in verbose mode');
+		this.logService.log(`from: ${this.environmentService.appRoot}`);
+		this.logService.log('args:', this.environmentService.args);
+
+		// Make sure we associate the program with the app user model id
+		// This will help Windows to associate the running program with
+		// any shortcut that is pinned to the taskbar and prevent showing
+		// two icons in the taskbar for the same app.
+		if (platform.isWindows && product.win32AppUserModelId) {
+			app.setAppUserModelId(product.win32AppUserModelId);
+		}
+
+		// Create Electron IPC Server
+		this.electronIpcServer = new ElectronIPCServer();
+
+		// Spawn shared process
+		this.sharedProcess = new SharedProcess(this.environmentService, this.userEnv);
+		this.toDispose.push(this.sharedProcess);
+		this.sharedProcessClient = this.sharedProcess.whenReady().then(() => connect(this.environmentService.sharedIPCHandle, 'main'));
+
+		// Services
+		const appInstantiationService = this.initServices();
+
+		// Setup Auth Handler
+		const authHandler = appInstantiationService.createInstance(ProxyAuthHandler);
+		this.toDispose.push(authHandler);
+
+		// {{SQL CARBON EDIT}}
+		// Setup OAuth Handler
+		const oauthHandler = appInstantiationService.createInstance(ProxyOAuthHandler);
+		this.toDispose.push(oauthHandler);
+
+		// Open Windows
+		appInstantiationService.invokeFunction(accessor => this.openFirstWindow(accessor));
+
+		// Post Open Windows Tasks
+		appInstantiationService.invokeFunction(accessor => this.afterWindowOpen(accessor));
+	}
+
+	private initServices(): IInstantiationService {
+		const services = new ServiceCollection();
+
+		services.set(IUpdateService, new SyncDescriptor(UpdateService));
+		services.set(IWindowsMainService, new SyncDescriptor(WindowsManager));
+		services.set(IWindowsService, new SyncDescriptor(WindowsService, this.sharedProcess));
+		services.set(ILaunchService, new SyncDescriptor(LaunchService));
+		services.set(ICredentialsService, new SyncDescriptor(CredentialsService));
+
+		// Telemtry
+		if (this.environmentService.isBuilt && !this.environmentService.isExtensionDevelopment && !!product.enableTelemetry) {
+			const channel = getDelayedChannel<ITelemetryAppenderChannel>(this.sharedProcessClient.then(c => c.getChannel('telemetryAppender')));
+			const appender = new TelemetryAppenderClient(channel);
+			const commonProperties = resolveCommonProperties(product.commit, pkg.version)
+				.then(result => Object.defineProperty(result, 'common.machineId', {
+					get: () => this.storageService.getItem(machineIdStorageKey),
+					enumerable: true
+				}));
+			const piiPaths = [this.environmentService.appRoot, this.environmentService.extensionsPath];
+			const config: ITelemetryServiceConfig = { appender, commonProperties, piiPaths };
+			services.set(ITelemetryService, new SyncDescriptor(TelemetryService, config));
+		} else {
+			services.set(ITelemetryService, NullTelemetryService);
+		}
+
+		return this.instantiationService.createChild(services);
+	}
+
+	private openFirstWindow(accessor: ServicesAccessor): void {
+		const appInstantiationService = accessor.get(IInstantiationService);
+
+		// TODO@Joao: unfold this
+		this.windowsMainService = accessor.get(IWindowsMainService);
+
+		// TODO@Joao: so ugly...
+		this.windowsMainService.onWindowsCountChanged(e => {
+			if (!platform.isMacintosh && e.newCount === 0) {
+				this.sharedProcess.dispose();
+			}
+		});
+
+		// Register more Main IPC services
+		const launchService = accessor.get(ILaunchService);
+		const launchChannel = new LaunchChannel(launchService);
+		this.mainIpcServer.registerChannel('launch', launchChannel);
+
+		// Register more Electron IPC services
+		const updateService = accessor.get(IUpdateService);
+		const updateChannel = new UpdateChannel(updateService);
+		this.electronIpcServer.registerChannel('update', updateChannel);
+
+		const urlService = accessor.get(IURLService);
+		const urlChannel = appInstantiationService.createInstance(URLChannel, urlService);
+		this.electronIpcServer.registerChannel('url', urlChannel);
+
+		const workspacesService = accessor.get(IWorkspacesMainService);
+		const workspacesChannel = appInstantiationService.createInstance(WorkspacesChannel, workspacesService);
+		this.electronIpcServer.registerChannel('workspaces', workspacesChannel);
+
+		const windowsService = accessor.get(IWindowsService);
+		const windowsChannel = new WindowsChannel(windowsService);
+		this.electronIpcServer.registerChannel('windows', windowsChannel);
+		this.sharedProcessClient.done(client => client.registerChannel('windows', windowsChannel));
+
+		const credentialsService = accessor.get(ICredentialsService);
+		const credentialsChannel = new CredentialsChannel(credentialsService);
+		this.electronIpcServer.registerChannel('credentials', credentialsChannel);
+
+		// Lifecycle
+		this.lifecycleService.ready();
+
+		// Propagate to clients
+		this.windowsMainService.ready(this.userEnv);
+
+		// Open our first window
+		const args = this.environmentService.args;
+		const context = !!process.env['VSCODE_CLI'] ? OpenContext.CLI : OpenContext.DESKTOP;
+		if (args['new-window'] && args._.length === 0) {
+			this.windowsMainService.open({ context, cli: args, forceNewWindow: true, forceEmpty: true, initialStartup: true }); // new window if "-n" was used without paths
+		} else if (global.macOpenFiles && global.macOpenFiles.length && (!args._ || !args._.length)) {
+			this.windowsMainService.open({ context: OpenContext.DOCK, cli: args, pathsToOpen: global.macOpenFiles, initialStartup: true }); // mac: open-file event received on startup
+		} else {
+			this.windowsMainService.open({ context, cli: args, forceNewWindow: args['new-window'] || (!args._.length && args['unity-launch']), diffMode: args.diff, initialStartup: true }); // default: read paths from cli
+		}
+	}
+
+	private afterWindowOpen(accessor: ServicesAccessor): void {
+		const appInstantiationService = accessor.get(IInstantiationService);
+
+		// Setup Windows mutex
+		let windowsMutex: Mutex = null;
+		if (platform.isWindows) {
+			try {
+				const Mutex = (require.__$__nodeRequire('windows-mutex') as any).Mutex;
+				windowsMutex = new Mutex(product.win32MutexName);
+				this.toDispose.push({ dispose: () => windowsMutex.release() });
+			} catch (e) {
+				// noop
+			}
+		}
+
+		// Install Menu
+		appInstantiationService.createInstance(CodeMenu);
+
+		// Jump List
+		this.historyService.updateWindowsJumpList();
+		this.historyService.onRecentlyOpenedChange(() => this.historyService.updateWindowsJumpList());
+
+		// Start shared process here
+		this.sharedProcess.spawn();
+
+		// Helps application icon refresh after an update with new icon is installed (macOS)
+		// TODO@Ben remove after a couple of releases
+		if (platform.isMacintosh) {
+			if (!this.storageService.getItem(CodeApplication.APP_ICON_REFRESH_KEY)) {
+				this.storageService.setItem(CodeApplication.APP_ICON_REFRESH_KEY, true);
+
+				// 'exe' => /Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Electron
+				const appPath = dirname(dirname(dirname(app.getPath('exe'))));
+				const infoPlistPath = join(appPath, 'Contents', 'Info.plist');
+				touch(appPath).done(null, error => { /* ignore */ });
+				touch(infoPlistPath).done(null, error => { /* ignore */ });
+			}
+		}
+	}
+
+	private dispose(): void {
+		this.toDispose = dispose(this.toDispose);
+	}
+}

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

@@ -0,0 +1,125 @@
+<!-- Copyright (C) Microsoft Corporation. All rights reserved. -->
+<!DOCTYPE html>
+<html>
+
+<head>
+	<meta charset="utf-8" />
+	<style>
+		html,
+		body {
+			margin: 0;
+			padding: 0;
+			height: 100%;
+			width: 100%;
+			overflow: hidden;
+			-webkit-touch-callout: none;
+			-webkit-user-select: none;
+			user-select: none;
+		}
+
+		body {
+			font-family: "Segoe WPC", "Segoe UI", "HelveticaNeue-Light", sans-serif, "Droid Sans Fallback";
+			font-size: 10pt;
+			background-color: #F3F3F3;
+		}
+
+		#main {
+			box-sizing: border-box;
+			padding: 10px;
+		}
+
+		h1 {
+			margin: 0;
+			padding: 10px 0;
+			font-size: 16px;
+			background-color: #555;
+			color: #f0f0f0;
+			text-align: center;
+		}
+
+		#form {
+			margin-top: 10px;
+		}
+
+		#username,
+		#password {
+			padding: 6px 10px;
+			font-size: 12px;
+			box-sizing: border-box;
+			width: 100%;
+		}
+
+		#buttons {
+			text-align: center;
+		}
+
+		p {
+			margin: 6px 0;
+		}
+
+		input {
+			font-family: "Segoe WPC", "Segoe UI", "HelveticaNeue-Light", sans-serif, "Droid Sans Fallback" !important;
+		}
+	</style>
+</head>
+
+<body>
+	<h1 id="title"></h1>
+	<section id="main">
+		<p id="message"></p>
+		<form id="form">
+			<p><input type="text" id="username" placeholder="Username" required/></p>
+			<p><input type="password" id="password" placeholder="Password" required/></p>
+			<p id="buttons">
+				<input id="ok" type="submit" value="OK" />
+				<input id="cancel" type="button" value="Cancel" />
+			</p>
+		</form>
+	</section>
+</body>
+
+<script>
+	const electron = require('electron');
+	const shell = electron.shell;
+	const ipc = electron.ipcRenderer;
+	const remote = electron.remote;
+	const currentWindow = remote.getCurrentWindow();
+
+	function promptForCredentials(data) {
+		return new Promise((c, e) => {
+			const $title = document.getElementById('title');
+			const $username = document.getElementById('username');
+			const $password = document.getElementById('password');
+			const $form = document.getElementById('form');
+			const $cancel = document.getElementById('cancel');
+			const $message = document.getElementById('message');
+
+			function submit() {
+				c({ username: $username.value, password: $password.value });
+				return false;
+			};
+
+			function cancel() {
+				c({ username: '', password: '' });
+				return false;
+			};
+
+			$form.addEventListener('submit', submit);
+			$cancel.addEventListener('click', cancel);
+
+			document.body.addEventListener('keydown', function (e) {
+				switch (e.keyCode) {
+					case 27: e.preventDefault(); e.stopPropagation(); return cancel();
+					case 13: e.preventDefault(); e.stopPropagation(); return submit();
+				}
+			});
+
+			$title.textContent = data.title;
+			$message.textContent = data.message;
+			$username.focus();
+		});
+	}
+
+</script>
+
+</html>

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

@@ -0,0 +1,93 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { localize } from 'vs/nls';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { IWindowsMainService } from 'vs/platform/windows/electron-main/windows';
+import { fromEventEmitter } from 'vs/base/node/event';
+import { BrowserWindow, app } from 'electron';
+
+type LoginEvent = {
+	event: Electron.Event;
+	webContents: Electron.WebContents;
+	req: Electron.LoginRequest;
+	authInfo: Electron.LoginAuthInfo;
+	cb: (username: string, password: string) => void;
+};
+
+type Credentials = {
+	username: string;
+	password: string;
+};
+
+export class ProxyAuthHandler {
+
+	_serviceBrand: any;
+
+	private retryCount = 0;
+	private disposables: IDisposable[] = [];
+
+	constructor(
+		@IWindowsMainService private windowsService: IWindowsMainService
+	) {
+		const onLogin = fromEventEmitter<LoginEvent>(app, 'login', (event, webContents, req, authInfo, cb) => ({ event, webContents, req, authInfo, cb }));
+		onLogin(this.onLogin, this, this.disposables);
+	}
+
+	private onLogin({ event, authInfo, cb }: LoginEvent): void {
+		if (!authInfo.isProxy) {
+			return;
+		}
+
+		if (this.retryCount++ > 1) {
+			return;
+		}
+
+		event.preventDefault();
+
+		const opts: any = {
+			alwaysOnTop: true,
+			skipTaskbar: true,
+			resizable: false,
+			width: 450,
+			height: 220,
+			show: true,
+			title: 'VS Code'
+		};
+
+		const focusedWindow = this.windowsService.getFocusedWindow();
+
+		if (focusedWindow) {
+			opts.parent = focusedWindow.win;
+			opts.modal = true;
+		}
+
+		const win = new BrowserWindow(opts);
+		const config = {};
+		const baseUrl = require.toUrl('./auth.html');
+		const url = `${baseUrl}?config=${encodeURIComponent(JSON.stringify(config))}`;
+		const proxyUrl = `${authInfo.host}:${authInfo.port}`;
+		const title = localize('authRequire', "Proxy Authentication Required");
+		const message = localize('proxyauth', "The proxy {0} requires authentication.", proxyUrl);
+		const data = { title, message };
+		const javascript = 'promptForCredentials(' + JSON.stringify(data) + ')';
+
+		const onWindowClose = () => cb('', '');
+		win.on('close', onWindowClose);
+
+		win.loadURL(url);
+		win.webContents.executeJavaScript(javascript, true).then(({ username, password }: Credentials) => {
+			cb(username, password);
+			win.removeListener('close', onWindowClose);
+			win.close();
+		});
+	}
+
+	dispose(): void {
+		this.disposables = dispose(this.disposables);
+	}
+}

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

@@ -0,0 +1,177 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as nativeKeymap from 'native-keymap';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { isMacintosh } from 'vs/base/common/platform';
+import { IStorageService } from 'vs/platform/storage/node/storage';
+import Event, { Emitter, once } from 'vs/base/common/event';
+import { ConfigWatcher } from 'vs/base/node/config';
+import { IUserFriendlyKeybinding } from 'vs/platform/keybinding/common/keybinding';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { ipcMain as ipc } from 'electron';
+import { IWindowsMainService } from 'vs/platform/windows/electron-main/windows';
+import { ILogService } from 'vs/platform/log/common/log';
+
+export class KeyboardLayoutMonitor {
+
+	public static readonly INSTANCE = new KeyboardLayoutMonitor();
+
+	private _emitter: Emitter<boolean>;
+	private _registered: boolean;
+	private _isISOKeyboard: boolean;
+
+	private constructor() {
+		this._emitter = new Emitter<boolean>();
+		this._registered = false;
+		this._isISOKeyboard = this._readIsISOKeyboard();
+	}
+
+	public onDidChangeKeyboardLayout(callback: (isISOKeyboard: boolean) => void): IDisposable {
+		if (!this._registered) {
+			this._registered = true;
+
+			nativeKeymap.onDidChangeKeyboardLayout(() => {
+				this._emitter.fire(this._isISOKeyboard);
+			});
+
+			if (isMacintosh) {
+				// See https://github.com/Microsoft/vscode/issues/24153
+				// On OSX, on ISO keyboards, Chromium swaps the scan codes
+				// of IntlBackslash and Backquote.
+				//
+				// The C++ methods can give the current keyboard type (ISO or not)
+				// only after a NSEvent was handled.
+				//
+				// We therefore poll.
+				setInterval(() => {
+					let newValue = this._readIsISOKeyboard();
+					if (this._isISOKeyboard === newValue) {
+						// no change
+						return;
+					}
+
+					this._isISOKeyboard = newValue;
+					this._emitter.fire(this._isISOKeyboard);
+
+				}, 3000);
+			}
+		}
+		return this._emitter.event(callback);
+	}
+
+	private _readIsISOKeyboard(): boolean {
+		if (isMacintosh) {
+			return nativeKeymap.isISOKeyboard();
+		}
+		return false;
+	}
+
+	public isISOKeyboard(): boolean {
+		return this._isISOKeyboard;
+	}
+}
+
+export interface IKeybinding {
+	id: string;
+	label: string;
+	isNative: boolean;
+}
+
+export class KeybindingsResolver {
+
+	private static lastKnownKeybindingsMapStorageKey = 'lastKnownKeybindings';
+
+	private commandIds: Set<string>;
+	private keybindings: { [commandId: string]: IKeybinding };
+	private keybindingsWatcher: ConfigWatcher<IUserFriendlyKeybinding[]>;
+
+	private _onKeybindingsChanged = new Emitter<void>();
+	onKeybindingsChanged: Event<void> = this._onKeybindingsChanged.event;
+
+	constructor(
+		@IStorageService private storageService: IStorageService,
+		@IEnvironmentService environmentService: IEnvironmentService,
+		@IWindowsMainService private windowsService: IWindowsMainService,
+		@ILogService private logService: ILogService
+	) {
+		this.commandIds = new Set<string>();
+		this.keybindings = this.storageService.getItem<{ [id: string]: string; }>(KeybindingsResolver.lastKnownKeybindingsMapStorageKey) || Object.create(null);
+		this.keybindingsWatcher = new ConfigWatcher<IUserFriendlyKeybinding[]>(environmentService.appKeybindingsPath, { changeBufferDelay: 100, onError: error => this.logService.error(error) });
+
+		this.registerListeners();
+	}
+
+	private registerListeners(): void {
+
+		// Listen to resolved keybindings from window
+		ipc.on('vscode:keybindingsResolved', (event, rawKeybindings: string) => {
+			let keybindings: IKeybinding[] = [];
+			try {
+				keybindings = JSON.parse(rawKeybindings);
+			} catch (error) {
+				// Should not happen
+			}
+
+			// Fill hash map of resolved keybindings and check for changes
+			let keybindingsChanged = false;
+			let keybindingsCount = 0;
+			const resolvedKeybindings: { [commandId: string]: IKeybinding } = Object.create(null);
+			keybindings.forEach(keybinding => {
+				keybindingsCount++;
+
+				resolvedKeybindings[keybinding.id] = keybinding;
+
+				if (!this.keybindings[keybinding.id] || keybinding.label !== this.keybindings[keybinding.id].label) {
+					keybindingsChanged = true;
+				}
+			});
+
+			// A keybinding might have been unassigned, so we have to account for that too
+			if (Object.keys(this.keybindings).length !== keybindingsCount) {
+				keybindingsChanged = true;
+			}
+
+			if (keybindingsChanged) {
+				this.keybindings = resolvedKeybindings;
+				this.storageService.setItem(KeybindingsResolver.lastKnownKeybindingsMapStorageKey, this.keybindings); // keep to restore instantly after restart
+
+				this._onKeybindingsChanged.fire();
+			}
+		});
+
+		// Resolve keybindings when any first window is loaded
+		const onceOnWindowReady = once(this.windowsService.onWindowReady);
+		onceOnWindowReady(win => this.resolveKeybindings(win));
+
+		// Resolve keybindings again when keybindings.json changes
+		this.keybindingsWatcher.onDidUpdateConfiguration(() => this.resolveKeybindings());
+
+		// Resolve keybindings when window reloads because an installed extension could have an impact
+		this.windowsService.onWindowReload(() => this.resolveKeybindings());
+	}
+
+	private resolveKeybindings(win = this.windowsService.getLastActiveWindow()): void {
+		if (this.commandIds.size && win) {
+			const commandIds = [];
+			this.commandIds.forEach(id => commandIds.push(id));
+			win.sendWhenReady('vscode:resolveKeybindings', JSON.stringify(commandIds));
+		}
+	}
+
+	public getKeybinding(commandId: string): IKeybinding {
+		if (!commandId) {
+			return void 0;
+		}
+
+		if (!this.commandIds.has(commandId)) {
+			this.commandIds.add(commandId);
+		}
+
+		return this.keybindings[commandId];
+	}
+}

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

@@ -0,0 +1,129 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TPromise } from 'vs/base/common/winjs.base';
+import { IChannel } from 'vs/base/parts/ipc/common/ipc';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IURLService } from 'vs/platform/url/common/url';
+import { IProcessEnvironment } from 'vs/base/common/platform';
+import { ParsedArgs } from 'vs/platform/environment/common/environment';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { OpenContext } from 'vs/platform/windows/common/windows';
+import { IWindowsMainService, ICodeWindow } from 'vs/platform/windows/electron-main/windows';
+
+export const ID = 'launchService';
+export const ILaunchService = createDecorator<ILaunchService>(ID);
+
+export interface IStartArguments {
+	args: ParsedArgs;
+	userEnv: IProcessEnvironment;
+}
+
+export interface ILaunchService {
+	_serviceBrand: any;
+	start(args: ParsedArgs, userEnv: IProcessEnvironment): TPromise<void>;
+	getMainProcessId(): TPromise<number>;
+}
+
+export interface ILaunchChannel extends IChannel {
+	call(command: 'start', arg: IStartArguments): TPromise<void>;
+	call(command: 'get-main-process-id', arg: null): TPromise<any>;
+	call(command: string, arg: any): TPromise<any>;
+}
+
+export class LaunchChannel implements ILaunchChannel {
+
+	constructor(private service: ILaunchService) { }
+
+	public call(command: string, arg: any): TPromise<any> {
+		switch (command) {
+			case 'start':
+				const { args, userEnv } = arg as IStartArguments;
+				return this.service.start(args, userEnv);
+
+			case 'get-main-process-id':
+				return this.service.getMainProcessId();
+		}
+
+		return undefined;
+	}
+}
+
+export class LaunchChannelClient implements ILaunchService {
+
+	_serviceBrand: any;
+
+	constructor(private channel: ILaunchChannel) { }
+
+	public start(args: ParsedArgs, userEnv: IProcessEnvironment): TPromise<void> {
+		return this.channel.call('start', { args, userEnv });
+	}
+
+	public getMainProcessId(): TPromise<number> {
+		return this.channel.call('get-main-process-id', null);
+	}
+}
+
+export class LaunchService implements ILaunchService {
+
+	_serviceBrand: any;
+
+	constructor(
+		@ILogService private logService: ILogService,
+		@IWindowsMainService private windowsService: IWindowsMainService,
+		@IURLService private urlService: IURLService
+	) { }
+
+	public start(args: ParsedArgs, userEnv: IProcessEnvironment): TPromise<void> {
+		this.logService.log('Received data from other instance: ', args, userEnv);
+
+		// Check early for open-url which is handled in URL service
+		const openUrlArg = args['open-url'] || [];
+		const openUrl = typeof openUrlArg === 'string' ? [openUrlArg] : openUrlArg;
+		if (openUrl.length > 0) {
+			openUrl.forEach(url => this.urlService.open(url));
+
+			return TPromise.as(null);
+		}
+
+		// Otherwise handle in windows service
+		const context = !!userEnv['VSCODE_CLI'] ? OpenContext.CLI : OpenContext.DESKTOP;
+		let usedWindows: ICodeWindow[];
+		if (!!args.extensionDevelopmentPath) {
+			this.windowsService.openExtensionDevelopmentHostWindow({ context, cli: args, userEnv });
+		} else if (args._.length === 0 && (args['new-window'] || args['unity-launch'])) {
+			usedWindows = this.windowsService.open({ context, cli: args, userEnv, forceNewWindow: true, forceEmpty: true });
+		} else if (args._.length === 0) {
+			usedWindows = [this.windowsService.focusLastActive(args, context)];
+		} else {
+			usedWindows = this.windowsService.open({
+				context,
+				cli: args,
+				userEnv,
+				forceNewWindow: args.wait || args['new-window'],
+				preferNewWindow: !args['reuse-window'],
+				forceReuseWindow: args['reuse-window'],
+				diffMode: args.diff,
+				addMode: args.add
+			});
+		}
+
+		// If the other instance is waiting to be killed, we hook up a window listener if one window
+		// is being used and only then resolve the startup promise which will kill this second instance
+		if (args.wait && usedWindows.length === 1 && usedWindows[0]) {
+			return this.windowsService.waitForWindowClose(usedWindows[0].id);
+		}
+
+		return TPromise.as(null);
+	}
+
+	public getMainProcessId(): TPromise<number> {
+		this.logService.log('Received request for process ID from other instance.');
+
+		return TPromise.as(process.pid);
+	}
+}

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

@@ -0,0 +1,217 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { app } from 'electron';
+import { assign } from 'vs/base/common/objects';
+import * as platform from 'vs/base/common/platform';
+import { parseMainProcessArgv } from 'vs/platform/environment/node/argv';
+import { mkdirp } from 'vs/base/node/pfs';
+import { validatePaths } from 'vs/code/node/paths';
+import { LifecycleService, ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
+import { Server, serve, connect } from 'vs/base/parts/ipc/node/ipc.net';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { ILaunchChannel, LaunchChannelClient } from './launch';
+import { ServicesAccessor, IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { InstantiationService } from 'vs/platform/instantiation/common/instantiationService';
+import { ServiceCollection } from 'vs/platform/instantiation/common/serviceCollection';
+import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
+import { ILogService, LogMainService } from 'vs/platform/log/common/log';
+import { IStorageService, StorageService } from 'vs/platform/storage/node/storage';
+import { IBackupMainService } from 'vs/platform/backup/common/backup';
+import { BackupMainService } from 'vs/platform/backup/electron-main/backupMainService';
+import { IEnvironmentService, ParsedArgs } from 'vs/platform/environment/common/environment';
+import { EnvironmentService } from 'vs/platform/environment/node/environmentService';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { ConfigurationService } from 'vs/platform/configuration/node/configurationService';
+import { IRequestService } from 'vs/platform/request/node/request';
+import { RequestService } from 'vs/platform/request/electron-main/requestService';
+import { IURLService } from 'vs/platform/url/common/url';
+import { URLService } from 'vs/platform/url/electron-main/urlService';
+import * as fs from 'original-fs';
+import { CodeApplication } from 'vs/code/electron-main/app';
+import { HistoryMainService } from 'vs/platform/history/electron-main/historyMainService';
+import { IHistoryMainService } from 'vs/platform/history/common/history';
+import { WorkspacesMainService } from 'vs/platform/workspaces/electron-main/workspacesMainService';
+import { IWorkspacesMainService } from 'vs/platform/workspaces/common/workspaces';
+
+function createServices(args: ParsedArgs): IInstantiationService {
+	const services = new ServiceCollection();
+
+	services.set(IEnvironmentService, new SyncDescriptor(EnvironmentService, args, process.execPath));
+	services.set(ILogService, new SyncDescriptor(LogMainService));
+	services.set(IWorkspacesMainService, new SyncDescriptor(WorkspacesMainService));
+	services.set(IHistoryMainService, new SyncDescriptor(HistoryMainService));
+	services.set(ILifecycleService, new SyncDescriptor(LifecycleService));
+	services.set(IStorageService, new SyncDescriptor(StorageService));
+	services.set(IConfigurationService, new SyncDescriptor(ConfigurationService));
+	services.set(IRequestService, new SyncDescriptor(RequestService));
+	services.set(IURLService, new SyncDescriptor(URLService, args['open-url']));
+	services.set(IBackupMainService, new SyncDescriptor(BackupMainService));
+
+	return new InstantiationService(services, true);
+}
+
+function createPaths(environmentService: IEnvironmentService): TPromise<any> {
+	const paths = [
+		environmentService.appSettingsHome,
+		environmentService.extensionsPath,
+		environmentService.nodeCachedDataDir
+	];
+	return TPromise.join(paths.map(p => p && mkdirp(p))) as TPromise<any>;
+}
+
+class ExpectedError extends Error {
+	public readonly isExpected = true;
+}
+
+function setupIPC(accessor: ServicesAccessor): TPromise<Server> {
+	const logService = accessor.get(ILogService);
+	const environmentService = accessor.get(IEnvironmentService);
+
+	function allowSetForegroundWindow(service: LaunchChannelClient): TPromise<void> {
+		let promise = TPromise.as<void>(void 0);
+		if (platform.isWindows) {
+			promise = service.getMainProcessId()
+				.then(processId => {
+					logService.log('Sending some foreground love to the running instance:', processId);
+
+					try {
+						const { allowSetForegroundWindow } = <any>require.__$__nodeRequire('windows-foreground-love');
+						allowSetForegroundWindow(processId);
+					} catch (e) {
+						// noop
+					}
+				});
+		}
+
+		return promise;
+	}
+
+	function setup(retry: boolean): TPromise<Server> {
+		return serve(environmentService.mainIPCHandle).then(server => {
+			if (platform.isMacintosh) {
+				app.dock.show(); // dock might be hidden at this case due to a retry
+			}
+
+			return server;
+		}, err => {
+			if (err.code !== 'EADDRINUSE') {
+				return TPromise.wrapError<Server>(err);
+			}
+
+			// Since we are the second instance, we do not want to show the dock
+			if (platform.isMacintosh) {
+				app.dock.hide();
+			}
+
+			// there's a running instance, let's connect to it
+			return connect(environmentService.mainIPCHandle, 'main').then(
+				client => {
+
+					// Tests from CLI require to be the only instance currently
+					if (environmentService.extensionTestsPath && !environmentService.debugExtensionHost.break) {
+						const msg = 'Running extension tests from the command line is currently only supported if no other instance of Code is running.';
+						logService.error(msg);
+						client.dispose();
+
+						return TPromise.wrapError<Server>(new Error(msg));
+					}
+
+					logService.log('Sending env to running instance...');
+
+					const channel = client.getChannel<ILaunchChannel>('launch');
+					const service = new LaunchChannelClient(channel);
+
+					return allowSetForegroundWindow(service)
+						.then(() => service.start(environmentService.args, process.env))
+						.then(() => client.dispose())
+						.then(() => TPromise.wrapError(new ExpectedError('Sent env to running instance. Terminating...')));
+				},
+				err => {
+					if (!retry || platform.isWindows || err.code !== 'ECONNREFUSED') {
+						return TPromise.wrapError<Server>(err);
+					}
+
+					// it happens on Linux and OS X that the pipe is left behind
+					// let's delete it, since we can't connect to it
+					// and the retry the whole thing
+					try {
+						fs.unlinkSync(environmentService.mainIPCHandle);
+					} catch (e) {
+						logService.log('Fatal error deleting obsolete instance handle', e);
+						return TPromise.wrapError<Server>(e);
+					}
+
+					return setup(false);
+				}
+			);
+		});
+	}
+
+	return setup(true);
+}
+
+function quit(accessor: ServicesAccessor, reason?: ExpectedError | Error): void {
+	const logService = accessor.get(ILogService);
+	const lifecycleService = accessor.get(ILifecycleService);
+
+	let exitCode = 0;
+
+	if (reason) {
+		if ((reason as ExpectedError).isExpected) {
+			logService.log(reason.message);
+		} else {
+			exitCode = 1; // signal error to the outside
+
+			if (reason.stack) {
+				console.error(reason.stack);
+			} else {
+				console.error(`Startup error: ${reason.toString()}`);
+			}
+		}
+	}
+
+	lifecycleService.kill(exitCode);
+}
+
+function main() {
+	let args: ParsedArgs;
+
+	try {
+		args = parseMainProcessArgv(process.argv);
+		args = validatePaths(args);
+	} catch (err) {
+		console.error(err.message);
+		app.exit(1);
+
+		return;
+	}
+
+	const instantiationService = createServices(args);
+
+	return instantiationService.invokeFunction(accessor => {
+
+		// Patch `process.env` with the instance's environment
+		const environmentService = accessor.get(IEnvironmentService);
+		const instanceEnv: typeof process.env = {
+			VSCODE_PID: String(process.pid),
+			VSCODE_IPC_HOOK: environmentService.mainIPCHandle,
+			VSCODE_NLS_CONFIG: process.env['VSCODE_NLS_CONFIG']
+		};
+		assign(process.env, instanceEnv);
+
+		// Startup
+		return instantiationService.invokeFunction(a => createPaths(a.get(IEnvironmentService)))
+			.then(() => instantiationService.invokeFunction(setupIPC))
+			.then(mainIpcServer => {
+				const app = instantiationService.createInstance(CodeApplication, mainIpcServer, instanceEnv);
+				app.startup();
+			});
+	}).done(null, err => instantiationService.invokeFunction(quit, err));
+}
+
+main();

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

@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { assign } from 'vs/base/common/objects';
+import { memoize } from 'vs/base/common/decorators';
+import { IDisposable, toDisposable, dispose } from 'vs/base/common/lifecycle';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { IProcessEnvironment } from 'vs/base/common/platform';
+import { BrowserWindow, ipcMain } from 'electron';
+import { PromiseSource } from 'vs/base/common/async';
+import { ISharedProcess } from 'vs/platform/windows/electron-main/windows';
+
+export class SharedProcess implements ISharedProcess {
+
+	private spawnPromiseSource: PromiseSource<void>;
+
+	private window: Electron.BrowserWindow;
+	private disposables: IDisposable[] = [];
+
+	@memoize
+	private get _whenReady(): TPromise<void> {
+		this.window = new BrowserWindow({
+			show: false,
+			webPreferences: {
+				images: false,
+				webaudio: false,
+				webgl: false
+			}
+		});
+		const config = assign({
+			appRoot: this.environmentService.appRoot,
+			nodeCachedDataDir: this.environmentService.nodeCachedDataDir,
+			userEnv: this.userEnv
+		});
+
+		const url = `${require.toUrl('vs/code/electron-browser/sharedProcess.html')}?config=${encodeURIComponent(JSON.stringify(config))}`;
+		this.window.loadURL(url);
+
+		// Prevent the window from dying
+		const onClose = e => {
+			if (this.window.isVisible()) {
+				e.preventDefault();
+				this.window.hide();
+			}
+		};
+
+		this.window.on('close', onClose);
+		this.disposables.push(toDisposable(() => this.window.removeListener('close', onClose)));
+
+		this.disposables.push(toDisposable(() => {
+
+			// Electron seems to crash on Windows without this setTimeout :|
+			setTimeout(() => {
+				try {
+					this.window.close();
+				} catch (err) {
+					// ignore, as electron is already shutting down
+				}
+
+				this.window = null;
+			}, 0);
+		}));
+
+		return new TPromise<void>((c, e) => {
+			ipcMain.once('handshake:hello', ({ sender }) => {
+				sender.send('handshake:hey there', {
+					sharedIPCHandle: this.environmentService.sharedIPCHandle,
+					args: this.environmentService.args
+				});
+
+				ipcMain.once('handshake:im ready', () => c(null));
+			});
+		});
+	}
+
+	constructor(
+		private environmentService: IEnvironmentService,
+		private userEnv: IProcessEnvironment
+	) {
+		this.spawnPromiseSource = new PromiseSource<void>();
+	}
+
+	public spawn(): void {
+		this.spawnPromiseSource.complete();
+	}
+
+	public whenReady(): TPromise<void> {
+		return this.spawnPromiseSource.value.then(() => this._whenReady);
+	}
+
+	public toggle(): void {
+		if (this.window.isVisible()) {
+			this.hide();
+		} else {
+			this.show();
+		}
+	}
+
+	public show(): void {
+		this.window.show();
+		this.window.webContents.openDevTools();
+	}
+
+	public hide(): void {
+		this.window.webContents.closeDevTools();
+		this.window.hide();
+	}
+
+	public dispose(): void {
+		this.disposables = dispose(this.disposables);
+	}
+}

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

@@ -0,0 +1,868 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as path from 'path';
+import * as objects from 'vs/base/common/objects';
+import { stopProfiling } from 'vs/base/node/profiler';
+import nls = require('vs/nls');
+import URI from 'vs/base/common/uri';
+import { IStorageService } from 'vs/platform/storage/node/storage';
+import { shell, screen, BrowserWindow, systemPreferences, app } from 'electron';
+import { TPromise, TValueCallback } from 'vs/base/common/winjs.base';
+import { IEnvironmentService, ParsedArgs } from 'vs/platform/environment/common/environment';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { parseArgs } from 'vs/platform/environment/node/argv';
+import product from 'vs/platform/node/product';
+import pkg from 'vs/platform/node/package';
+import { IWindowSettings, MenuBarVisibility, IWindowConfiguration, ReadyState } from 'vs/platform/windows/common/windows';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { KeyboardLayoutMonitor } from 'vs/code/electron-main/keyboard';
+import { isLinux, isMacintosh, isWindows } from 'vs/base/common/platform';
+import { ICodeWindow } from 'vs/platform/windows/electron-main/windows';
+import { IWorkspaceIdentifier, IWorkspacesMainService } from 'vs/platform/workspaces/common/workspaces';
+import { IBackupMainService } from 'vs/platform/backup/common/backup';
+
+export interface IWindowState {
+	width?: number;
+	height?: number;
+	x?: number;
+	y?: number;
+	mode?: WindowMode;
+	display?: number;
+}
+
+export interface IWindowCreationOptions {
+	state: IWindowState;
+	extensionDevelopmentPath?: string;
+	isExtensionTestHost?: boolean;
+}
+
+export enum WindowMode {
+	Maximized,
+	Normal,
+	Minimized, // not used anymore, but also cannot remove due to existing stored UI state (needs migration)
+	Fullscreen
+}
+
+export const defaultWindowState = function (mode = WindowMode.Normal): IWindowState {
+	return {
+		width: 1024,
+		height: 768,
+		mode
+	};
+};
+
+interface IWorkbenchEditorConfiguration {
+	workbench: {
+		editor: {
+			swipeToNavigate: boolean
+		}
+	};
+}
+
+export class CodeWindow implements ICodeWindow {
+
+	public static themeStorageKey = 'theme';
+	public static themeBackgroundStorageKey = 'themeBackground';
+
+	private static MIN_WIDTH = 200;
+	private static MIN_HEIGHT = 120;
+
+	private hiddenTitleBarStyle: boolean;
+	private showTimeoutHandle: any;
+	private _id: number;
+	private _win: Electron.BrowserWindow;
+	private _lastFocusTime: number;
+	private _readyState: ReadyState;
+	private windowState: IWindowState;
+	private currentMenuBarVisibility: MenuBarVisibility;
+	private toDispose: IDisposable[];
+	private representedFilename: string;
+
+	private whenReadyCallbacks: TValueCallback<CodeWindow>[];
+
+	private currentConfig: IWindowConfiguration;
+	private pendingLoadConfig: IWindowConfiguration;
+
+	constructor(
+		config: IWindowCreationOptions,
+		@ILogService private logService: ILogService,
+		@IEnvironmentService private environmentService: IEnvironmentService,
+		@IConfigurationService private configurationService: IConfigurationService,
+		@IStorageService private storageService: IStorageService,
+		@IWorkspacesMainService private workspaceService: IWorkspacesMainService,
+		@IBackupMainService private backupService: IBackupMainService
+	) {
+		this._lastFocusTime = -1;
+		this._readyState = ReadyState.NONE;
+		this.whenReadyCallbacks = [];
+		this.toDispose = [];
+
+		// create browser window
+		this.createBrowserWindow(config);
+
+		// respect configured menu bar visibility
+		this.onConfigurationUpdated();
+
+		// Eventing
+		this.registerListeners();
+	}
+
+	private createBrowserWindow(config: IWindowCreationOptions): void {
+
+		// Load window state
+		this.windowState = this.restoreWindowState(config.state);
+
+		// in case we are maximized or fullscreen, only show later after the call to maximize/fullscreen (see below)
+		const isFullscreenOrMaximized = (this.windowState.mode === WindowMode.Maximized || this.windowState.mode === WindowMode.Fullscreen);
+
+		const options: Electron.BrowserWindowOptions = {
+			width: this.windowState.width,
+			height: this.windowState.height,
+			x: this.windowState.x,
+			y: this.windowState.y,
+			backgroundColor: this.getBackgroundColor(),
+			minWidth: CodeWindow.MIN_WIDTH,
+			minHeight: CodeWindow.MIN_HEIGHT,
+			show: !isFullscreenOrMaximized,
+			title: product.nameLong,
+			webPreferences: {
+				'backgroundThrottling': false, // by default if Code is in the background, intervals and timeouts get throttled,
+				disableBlinkFeatures: 'Auxclick' // disable auxclick events (see https://developers.google.com/web/updates/2016/10/auxclick)
+			}
+		};
+
+		if (isLinux) {
+			options.icon = path.join(this.environmentService.appRoot, 'resources/linux/code.png'); // Windows and Mac are better off using the embedded icon(s)
+		}
+
+		const windowConfig = this.configurationService.getConfiguration<IWindowSettings>('window');
+
+		let useNativeTabs = false;
+		if (windowConfig && windowConfig.nativeTabs) {
+			options.tabbingIdentifier = product.nameShort; // this opts in to sierra tabs
+			useNativeTabs = true;
+		}
+
+		let useCustomTitleStyle = false;
+
+		// {{SQL CARBON EDIT}}
+		// turn-off custom menus to avoid bug calculating size of SQL editor
+		/*
+		if (isMacintosh && (!windowConfig || !windowConfig.titleBarStyle || windowConfig.titleBarStyle === 'custom')) {
+			const isDev = !this.environmentService.isBuilt || !!config.extensionDevelopmentPath;
+			if (!isDev) {
+				useCustomTitleStyle = true; // not enabled when developing due to https://github.com/electron/electron/issues/3647
+			}
+		}
+		*/
+
+		if (useNativeTabs) {
+			useCustomTitleStyle = false; // native tabs on sierra do not work with custom title style
+		}
+
+		if (useCustomTitleStyle) {
+			options.titleBarStyle = 'hidden';
+			this.hiddenTitleBarStyle = true;
+		}
+
+		// Create the browser window.
+		this._win = new BrowserWindow(options);
+		this._id = this._win.id;
+
+		if (useCustomTitleStyle) {
+			this._win.setSheetOffset(22); // offset dialogs by the height of the custom title bar if we have any
+		}
+
+		// Set relaunch command
+		if (isWindows && product.win32AppUserModelId && typeof this._win.setAppDetails === 'function') {
+			this._win.setAppDetails({
+				appId: product.win32AppUserModelId,
+				relaunchCommand: `"${process.execPath}" -n`,
+				relaunchDisplayName: product.nameLong
+			});
+		}
+
+		if (isFullscreenOrMaximized) {
+			this._win.maximize();
+
+			if (this.windowState.mode === WindowMode.Fullscreen) {
+				this._win.setFullScreen(true);
+			}
+
+			if (!this._win.isVisible()) {
+				this._win.show(); // to reduce flicker from the default window size to maximize, we only show after maximize
+			}
+		}
+
+		this._lastFocusTime = Date.now(); // since we show directly, we need to set the last focus time too
+	}
+
+	public hasHiddenTitleBarStyle(): boolean {
+		return this.hiddenTitleBarStyle;
+	}
+
+	public get isExtensionDevelopmentHost(): boolean {
+		return !!this.config.extensionDevelopmentPath;
+	}
+
+	public get isExtensionTestHost(): boolean {
+		return !!this.config.extensionTestsPath;
+	}
+
+	public get extensionDevelopmentPath(): string {
+		return this.config.extensionDevelopmentPath;
+	}
+
+	public get config(): IWindowConfiguration {
+		return this.currentConfig;
+	}
+
+	public get id(): number {
+		return this._id;
+	}
+
+	public get win(): Electron.BrowserWindow {
+		return this._win;
+	}
+
+	public setRepresentedFilename(filename: string): void {
+		if (isMacintosh) {
+			this.win.setRepresentedFilename(filename);
+		} else {
+			this.representedFilename = filename;
+		}
+	}
+
+	public getRepresentedFilename(): string {
+		if (isMacintosh) {
+			return this.win.getRepresentedFilename();
+		}
+
+		return this.representedFilename;
+	}
+
+	public focus(): void {
+		if (!this._win) {
+			return;
+		}
+
+		if (this._win.isMinimized()) {
+			this._win.restore();
+		}
+
+		this._win.focus();
+	}
+
+	public get lastFocusTime(): number {
+		return this._lastFocusTime;
+	}
+
+	public get backupPath(): string {
+		return this.currentConfig ? this.currentConfig.backupPath : void 0;
+	}
+
+	public get openedWorkspace(): IWorkspaceIdentifier {
+		return this.currentConfig ? this.currentConfig.workspace : void 0;
+	}
+
+	public get openedFolderPath(): string {
+		return this.currentConfig ? this.currentConfig.folderPath : void 0;
+	}
+
+	public get openedFilePath(): string {
+		return this.currentConfig && this.currentConfig.filesToOpen && this.currentConfig.filesToOpen[0] && this.currentConfig.filesToOpen[0].filePath;
+	}
+
+	public setReady(): void {
+		this._readyState = ReadyState.READY;
+
+		// inform all waiting promises that we are ready now
+		while (this.whenReadyCallbacks.length) {
+			this.whenReadyCallbacks.pop()(this);
+		}
+	}
+
+	public ready(): TPromise<CodeWindow> {
+		return new TPromise<CodeWindow>((c) => {
+			if (this._readyState === ReadyState.READY) {
+				return c(this);
+			}
+
+			// otherwise keep and call later when we are ready
+			this.whenReadyCallbacks.push(c);
+		});
+	}
+
+	public get readyState(): ReadyState {
+		return this._readyState;
+	}
+
+	private registerListeners(): void {
+		const urls = ['https://marketplace.visualstudio.com/*', 'https://*.vsassets.io/*'];
+		const headers = {
+			'X-Market-Client-Id': `VSCode ${pkg.version}`,
+			'User-Agent': `VSCode ${pkg.version}`,
+			'X-Market-User-Id': this.environmentService.machineUUID
+		};
+
+		this._win.webContents.session.webRequest.onBeforeSendHeaders({ urls }, (details, cb) => {
+			cb({ cancel: false, requestHeaders: objects.assign(details.requestHeaders, headers) });
+		});
+
+		// Prevent loading of svgs
+		this._win.webContents.session.webRequest.onBeforeRequest((details, callback) => {
+			if (details.url.indexOf('.svg') > 0) {
+				const uri = URI.parse(details.url);
+				if (uri && !uri.scheme.match(/file/i) && (uri.path as any).endsWith('.svg')) {
+					return callback({ cancel: true });
+				}
+			}
+
+			return callback({});
+		});
+
+		this._win.webContents.session.webRequest.onHeadersReceived((details, callback) => {
+			const contentType: string[] = (details.responseHeaders['content-type'] || details.responseHeaders['Content-Type']) as any;
+			if (contentType && Array.isArray(contentType) && contentType.some(x => x.toLowerCase().indexOf('image/svg') >= 0)) {
+				return callback({ cancel: true });
+			}
+
+			return callback({ cancel: false, responseHeaders: details.responseHeaders });
+		});
+
+		// Remember that we loaded
+		this._win.webContents.on('did-finish-load', () => {
+			this._readyState = ReadyState.LOADING;
+
+			// Associate properties from the load request if provided
+			if (this.pendingLoadConfig) {
+				this.currentConfig = this.pendingLoadConfig;
+
+				this.pendingLoadConfig = null;
+			}
+
+			// To prevent flashing, we set the window visible after the page has finished to load but before Code is loaded
+			if (!this._win.isVisible()) {
+				if (this.windowState.mode === WindowMode.Maximized) {
+					this._win.maximize();
+				}
+
+				if (!this._win.isVisible()) { // maximize also makes visible
+					this._win.show();
+				}
+			}
+		});
+
+		// App commands support
+		this.registerNavigationListenerOn('app-command', 'browser-backward', 'browser-forward', false);
+
+		// Handle code that wants to open links
+		this._win.webContents.on('new-window', (event: Event, url: string) => {
+			event.preventDefault();
+
+			shell.openExternal(url);
+		});
+
+		// Window Focus
+		this._win.on('focus', () => {
+			this._lastFocusTime = Date.now();
+		});
+
+		// Window Fullscreen
+		this._win.on('enter-full-screen', () => {
+			this.sendWhenReady('vscode:enterFullScreen');
+		});
+
+		this._win.on('leave-full-screen', () => {
+			this.sendWhenReady('vscode:leaveFullScreen');
+		});
+
+		// Window Failed to load
+		this._win.webContents.on('did-fail-load', (event: Event, errorCode: string, errorDescription: string) => {
+			this.logService.warn('[electron event]: fail to load, ', errorDescription);
+		});
+
+		// Prevent any kind of navigation triggered by the user!
+		// But do not touch this in dev version because it will prevent "Reload" from dev tools
+		if (this.environmentService.isBuilt) {
+			this._win.webContents.on('will-navigate', (event: Event) => {
+				if (event) {
+					event.preventDefault();
+				}
+			});
+		}
+
+		// Handle configuration changes
+		this.toDispose.push(this.configurationService.onDidUpdateConfiguration(e => this.onConfigurationUpdated()));
+
+		// Handle Workspace events
+		this.toDispose.push(this.workspaceService.onUntitledWorkspaceDeleted(e => this.onUntitledWorkspaceDeleted(e)));
+	}
+
+	private onUntitledWorkspaceDeleted(workspace: IWorkspaceIdentifier): void {
+
+		// Make sure to update our workspace config if we detect that it
+		// was deleted
+		if (this.openedWorkspace && this.openedWorkspace.id === workspace.id) {
+			this.currentConfig.workspace = void 0;
+		}
+	}
+
+	private onConfigurationUpdated(): void {
+		const newMenuBarVisibility = this.getMenuBarVisibility();
+		if (newMenuBarVisibility !== this.currentMenuBarVisibility) {
+			this.currentMenuBarVisibility = newMenuBarVisibility;
+			this.setMenuBarVisibility(newMenuBarVisibility);
+		}
+
+		// Swipe command support (macOS)
+		if (isMacintosh) {
+			const config = this.configurationService.getConfiguration<IWorkbenchEditorConfiguration>();
+			if (config && config.workbench && config.workbench.editor && config.workbench.editor.swipeToNavigate) {
+				this.registerNavigationListenerOn('swipe', 'left', 'right', true);
+			} else {
+				this._win.removeAllListeners('swipe');
+			}
+		}
+	};
+
+	private registerNavigationListenerOn(command: 'swipe' | 'app-command', back: 'left' | 'browser-backward', forward: 'right' | 'browser-forward', acrossEditors: boolean) {
+		this._win.on(command, (e, cmd) => {
+			if (this.readyState !== ReadyState.READY) {
+				return; // window must be ready
+			}
+
+			if (cmd === back) {
+				this.send('vscode:runAction', acrossEditors ? 'workbench.action.openPreviousRecentlyUsedEditor' : 'workbench.action.navigateBack');
+			} else if (cmd === forward) {
+				this.send('vscode:runAction', acrossEditors ? 'workbench.action.openNextRecentlyUsedEditor' : 'workbench.action.navigateForward');
+			}
+		});
+	}
+
+	public load(config: IWindowConfiguration, isReload?: boolean): void {
+
+		// If this is the first time the window is loaded, we associate the paths
+		// directly with the window because we assume the loading will just work
+		if (this.readyState === ReadyState.NONE) {
+			this.currentConfig = config;
+		}
+
+		// Otherwise, the window is currently showing a folder and if there is an
+		// unload handler preventing the load, we cannot just associate the paths
+		// because the loading might be vetoed. Instead we associate it later when
+		// the window load event has fired.
+		else {
+			this.pendingLoadConfig = config;
+			this._readyState = ReadyState.NAVIGATING;
+		}
+
+		// Clear Document Edited if needed
+		if (isMacintosh && this._win.isDocumentEdited()) {
+			if (!isReload || !this.backupService.isHotExitEnabled()) {
+				this._win.setDocumentEdited(false);
+			}
+		}
+
+		// Clear Title and Filename if needed
+		if (!isReload) {
+			if (this.getRepresentedFilename()) {
+				this.setRepresentedFilename('');
+			}
+
+			this._win.setTitle(product.nameLong);
+		}
+
+		// Load URL
+		this._win.loadURL(this.getUrl(config));
+
+		// Make window visible if it did not open in N seconds because this indicates an error
+		// Only do this when running out of sources and not when running tests
+		if (!this.environmentService.isBuilt && !this.environmentService.extensionTestsPath) {
+			this.showTimeoutHandle = setTimeout(() => {
+				if (this._win && !this._win.isVisible() && !this._win.isMinimized()) {
+					this._win.show();
+					this._win.focus();
+					this._win.webContents.openDevTools();
+				}
+			}, 10000);
+		}
+
+		// (--prof-startup) save profile to disk
+		const { profileStartup } = this.environmentService;
+		if (profileStartup) {
+			stopProfiling(profileStartup.dir, profileStartup.prefix).done(undefined, err => this.logService.error(err));
+		}
+	}
+
+	public reload(configuration?: IWindowConfiguration, cli?: ParsedArgs): void {
+
+		// If config is not provided, copy our current one
+		if (!configuration) {
+			configuration = objects.mixin({}, this.currentConfig);
+		}
+
+		// Delete some properties we do not want during reload
+		delete configuration.filesToOpen;
+		delete configuration.filesToCreate;
+		delete configuration.filesToDiff;
+
+		// Some configuration things get inherited if the window is being reloaded and we are
+		// in extension development mode. These options are all development related.
+		if (this.isExtensionDevelopmentHost && cli) {
+			configuration.verbose = cli.verbose;
+			configuration.debugPluginHost = cli.debugPluginHost;
+			configuration.debugBrkPluginHost = cli.debugBrkPluginHost;
+			configuration.debugId = cli.debugId;
+			configuration['extensions-dir'] = cli['extensions-dir'];
+		}
+
+		configuration.isInitialStartup = false; // since this is a reload
+
+		// Load config
+		this.load(configuration, true);
+	}
+
+	private getUrl(windowConfiguration: IWindowConfiguration): string {
+
+		// Set zoomlevel
+		const windowConfig = this.configurationService.getConfiguration<IWindowSettings>('window');
+		const zoomLevel = windowConfig && windowConfig.zoomLevel;
+		if (typeof zoomLevel === 'number') {
+			windowConfiguration.zoomLevel = zoomLevel;
+		}
+
+		// Set fullscreen state
+		windowConfiguration.fullscreen = this._win.isFullScreen();
+
+		// Set Accessibility Config
+		windowConfiguration.highContrast = isWindows && systemPreferences.isInvertedColorScheme() && (!windowConfig || windowConfig.autoDetectHighContrast);
+		windowConfiguration.accessibilitySupport = app.isAccessibilitySupportEnabled();
+
+		// Set Keyboard Config
+		windowConfiguration.isISOKeyboard = KeyboardLayoutMonitor.INSTANCE.isISOKeyboard();
+
+		// Theme
+		windowConfiguration.baseTheme = this.getBaseTheme();
+		windowConfiguration.backgroundColor = this.getBackgroundColor();
+
+		// Perf Counters
+		windowConfiguration.perfStartTime = global.perfStartTime;
+		windowConfiguration.perfAppReady = global.perfAppReady;
+		windowConfiguration.perfWindowLoadTime = Date.now();
+
+		// Config (combination of process.argv and window configuration)
+		const environment = parseArgs(process.argv);
+		const config = objects.assign(environment, windowConfiguration);
+		for (let key in config) {
+			if (!config[key]) {
+				delete config[key]; // only send over properties that have a true value
+			}
+		}
+
+		return `${require.toUrl('vs/workbench/electron-browser/bootstrap/index.html')}?config=${encodeURIComponent(JSON.stringify(config))}`;
+	}
+
+	private getBaseTheme(): string {
+		if (isWindows && systemPreferences.isInvertedColorScheme()) {
+			return 'hc-black';
+		}
+
+		const theme = this.storageService.getItem<string>(CodeWindow.themeStorageKey, 'vs-dark');
+
+		return theme.split(' ')[0];
+	}
+
+	private getBackgroundColor(): string {
+		if (isWindows && systemPreferences.isInvertedColorScheme()) {
+			return '#000000';
+		}
+
+		const background = this.storageService.getItem<string>(CodeWindow.themeBackgroundStorageKey, null);
+		if (!background) {
+			const baseTheme = this.getBaseTheme();
+
+			return baseTheme === 'hc-black' ? '#000000' : (baseTheme === 'vs' ? '#FFFFFF' : (isMacintosh ? '#171717' : '#1E1E1E')); // https://github.com/electron/electron/issues/5150
+		}
+
+		return background;
+	}
+
+	public serializeWindowState(): IWindowState {
+
+		// fullscreen gets special treatment
+		if (this._win.isFullScreen()) {
+			const display = screen.getDisplayMatching(this.getBounds());
+
+			return {
+				mode: WindowMode.Fullscreen,
+				display: display ? display.id : void 0,
+
+				// still carry over window dimensions from previous sessions!
+				width: this.windowState.width,
+				height: this.windowState.height,
+				x: this.windowState.x,
+				y: this.windowState.y
+			};
+		}
+
+		const state: IWindowState = Object.create(null);
+		let mode: WindowMode;
+
+		// get window mode
+		if (!isMacintosh && this._win.isMaximized()) {
+			mode = WindowMode.Maximized;
+		} else {
+			mode = WindowMode.Normal;
+		}
+
+		// we don't want to save minimized state, only maximized or normal
+		if (mode === WindowMode.Maximized) {
+			state.mode = WindowMode.Maximized;
+		} else {
+			state.mode = WindowMode.Normal;
+		}
+
+		// only consider non-minimized window states
+		if (mode === WindowMode.Normal || mode === WindowMode.Maximized) {
+			const bounds = this.getBounds();
+
+			state.x = bounds.x;
+			state.y = bounds.y;
+			state.width = bounds.width;
+			state.height = bounds.height;
+		}
+
+		return state;
+	}
+
+	private restoreWindowState(state?: IWindowState): IWindowState {
+		if (state) {
+			try {
+				state = this.validateWindowState(state);
+			} catch (err) {
+				this.logService.log(`Unexpected error validating window state: ${err}\n${err.stack}`); // somehow display API can be picky about the state to validate
+			}
+		}
+
+		if (!state) {
+			state = defaultWindowState();
+		}
+
+		return state;
+	}
+
+	private validateWindowState(state: IWindowState): IWindowState {
+		if (!state) {
+			return null;
+		}
+
+		if ([state.x, state.y, state.width, state.height].some(n => typeof n !== 'number')) {
+			return null;
+		}
+
+		if (state.width <= 0 || state.height <= 0) {
+			return null;
+		}
+
+		const displays = screen.getAllDisplays();
+
+		// Single Monitor: be strict about x/y positioning
+		if (displays.length === 1) {
+			const displayBounds = displays[0].bounds;
+
+			// Careful with maximized: in that mode x/y can well be negative!
+			if (state.mode !== WindowMode.Maximized && displayBounds.width > 0 && displayBounds.height > 0 /* Linux X11 sessions sometimes report wrong display bounds */) {
+				if (state.x < displayBounds.x) {
+					state.x = displayBounds.x; // prevent window from falling out of the screen to the left
+				}
+
+				if (state.y < displayBounds.y) {
+					state.y = displayBounds.y; // prevent window from falling out of the screen to the top
+				}
+
+				if (state.x > (displayBounds.x + displayBounds.width)) {
+					state.x = displayBounds.x; // prevent window from falling out of the screen to the right
+				}
+
+				if (state.y > (displayBounds.y + displayBounds.height)) {
+					state.y = displayBounds.y; // prevent window from falling out of the screen to the bottom
+				}
+
+				if (state.width > displayBounds.width) {
+					state.width = displayBounds.width; // prevent window from exceeding display bounds width
+				}
+
+				if (state.height > displayBounds.height) {
+					state.height = displayBounds.height; // prevent window from exceeding display bounds height
+				}
+			}
+
+			if (state.mode === WindowMode.Maximized) {
+				return defaultWindowState(WindowMode.Maximized); // when maximized, make sure we have good values when the user restores the window
+			}
+
+			return state;
+		}
+
+		// Multi Montior (fullscreen): try to find the previously used display
+		if (state.display && state.mode === WindowMode.Fullscreen) {
+			const display = displays.filter(d => d.id === state.display)[0];
+			if (display && display.bounds && typeof display.bounds.x === 'number' && typeof display.bounds.y === 'number') {
+				const defaults = defaultWindowState(WindowMode.Fullscreen); // make sure we have good values when the user restores the window
+				defaults.x = display.bounds.x; // carefull to use displays x/y position so that the window ends up on the correct monitor
+				defaults.y = display.bounds.y;
+
+				return defaults;
+			}
+		}
+
+		// Multi Monitor (non-fullscreen): be less strict because metrics can be crazy
+		const bounds = { x: state.x, y: state.y, width: state.width, height: state.height };
+		const display = screen.getDisplayMatching(bounds);
+		if (display && display.bounds.x + display.bounds.width > bounds.x && display.bounds.y + display.bounds.height > bounds.y) {
+			if (state.mode === WindowMode.Maximized) {
+				const defaults = defaultWindowState(WindowMode.Maximized); // when maximized, make sure we have good values when the user restores the window
+				defaults.x = state.x; // carefull to keep x/y position so that the window ends up on the correct monitor
+				defaults.y = state.y;
+
+				return defaults;
+			}
+
+			return state;
+		}
+
+		return null;
+	}
+
+	public getBounds(): Electron.Rectangle {
+		const pos = this._win.getPosition();
+		const dimension = this._win.getSize();
+
+		return { x: pos[0], y: pos[1], width: dimension[0], height: dimension[1] };
+	}
+
+	public toggleFullScreen(): void {
+		const willBeFullScreen = !this._win.isFullScreen();
+
+		// set fullscreen flag on window
+		this._win.setFullScreen(willBeFullScreen);
+
+		// respect configured menu bar visibility or default to toggle if not set
+		this.setMenuBarVisibility(this.currentMenuBarVisibility, false);
+	}
+
+	private getMenuBarVisibility(): MenuBarVisibility {
+		const windowConfig = this.configurationService.getConfiguration<IWindowSettings>('window');
+		if (!windowConfig || !windowConfig.menuBarVisibility) {
+			return 'default';
+		}
+
+		let menuBarVisibility = windowConfig.menuBarVisibility;
+		if (['visible', 'toggle', 'hidden'].indexOf(menuBarVisibility) < 0) {
+			menuBarVisibility = 'default';
+		}
+
+		return menuBarVisibility;
+	}
+
+	public setMenuBarVisibility(visibility: MenuBarVisibility, notify: boolean = true): void {
+		if (isMacintosh) {
+			return; // ignore for macOS platform
+		}
+
+		const isFullscreen = this._win.isFullScreen();
+
+		switch (visibility) {
+			case ('default'):
+				this._win.setMenuBarVisibility(!isFullscreen);
+				this._win.setAutoHideMenuBar(isFullscreen);
+				break;
+
+			case ('visible'):
+				this._win.setMenuBarVisibility(true);
+				this._win.setAutoHideMenuBar(false);
+				break;
+
+			case ('toggle'):
+				this._win.setMenuBarVisibility(false);
+				this._win.setAutoHideMenuBar(true);
+
+				if (notify) {
+					this.send('vscode:showInfoMessage', nls.localize('hiddenMenuBar', "You can still access the menu bar by pressing the **Alt** key."));
+				};
+				break;
+
+			case ('hidden'):
+				// for some weird reason that I have no explanation for, the menu bar is not hiding when calling
+				// this without timeout (see https://github.com/Microsoft/vscode/issues/19777). there seems to be
+				// a timing issue with us opening the first window and the menu bar getting created. somehow the
+				// fact that we want to hide the menu without being able to bring it back via Alt key makes Electron
+				// still show the menu. Unable to reproduce from a simple Hello World application though...
+				setTimeout(() => {
+					this._win.setMenuBarVisibility(false);
+					this._win.setAutoHideMenuBar(false);
+				});
+				break;
+		};
+	}
+
+	public onWindowTitleDoubleClick(): void {
+
+		// Respect system settings on mac with regards to title click on windows title
+		if (isMacintosh) {
+			const action = systemPreferences.getUserDefault('AppleActionOnDoubleClick', 'string');
+			switch (action) {
+				case 'Minimize':
+					this.win.minimize();
+					break;
+				case 'None':
+					break;
+				case 'Maximize':
+				default:
+					this.win.maximize();
+			}
+		}
+
+		// Linux/Windows: just toggle maximize/minimized state
+		else {
+			if (this.win.isMaximized()) {
+				this.win.unmaximize();
+			} else {
+				this.win.maximize();
+			}
+		}
+	}
+
+	public close(): void {
+		if (this._win) {
+			this._win.close();
+		}
+	}
+
+	public sendWhenReady(channel: string, ...args: any[]): void {
+		this.ready().then(() => {
+			this.send(channel, ...args);
+		});
+	}
+
+	public send(channel: string, ...args: any[]): void {
+		this._win.webContents.send(channel, ...args);
+	}
+
+	public dispose(): void {
+		if (this.showTimeoutHandle) {
+			clearTimeout(this.showTimeoutHandle);
+		}
+
+		this.toDispose = dispose(this.toDispose);
+
+		this._win = null; // Important to dereference the window object to allow for GC
+	}
+}