Merge from vscode a234f13c45b40a0929777cb440ee011b7549eed2 (#8911)

* Merge from vscode a234f13c45b40a0929777cb440ee011b7549eed2 * update distro * fix layering * update distro * fix tests
2026-01-26 17:23:15 -05:00 · 2020-01-22 13:42:37 -08:00
parent 977111eb21
commit bd7aac8ee0
895 changed files with 24651 additions and 14520 deletions
--- a/src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts
+++ b/src/vs/code/electron-browser/sharedProcess/sharedProcessMain.ts
@@ -50,19 +50,18 @@ import { IFileService } from 'vs/platform/files/common/files';
 import { DiskFileSystemProvider } from 'vs/platform/files/electron-browser/diskFileSystemProvider';
 import { Schemas } from 'vs/base/common/network';
 import { IProductService } from 'vs/platform/product/common/productService';
-import { IUserDataSyncService, IUserDataSyncStoreService, registerConfiguration, IUserDataSyncLogService, IUserDataSyncUtilService } from 'vs/platform/userDataSync/common/userDataSync';
+import { IUserDataSyncService, IUserDataSyncStoreService, registerConfiguration, IUserDataSyncLogService, IUserDataSyncUtilService, ISettingsSyncService, IUserDataAuthTokenService } from 'vs/platform/userDataSync/common/userDataSync';
 import { UserDataSyncService } from 'vs/platform/userDataSync/common/userDataSyncService';
 import { UserDataSyncStoreService } from 'vs/platform/userDataSync/common/userDataSyncStoreService';
-import { UserDataSyncChannel, UserDataSyncUtilServiceClient } from 'vs/platform/userDataSync/common/userDataSyncIpc';
+import { UserDataSyncChannel, UserDataSyncUtilServiceClient, SettingsSyncChannel, UserDataAuthTokenServiceChannel, UserDataAutoSyncChannel } from 'vs/platform/userDataSync/common/userDataSyncIpc';
 import { IElectronService } from 'vs/platform/electron/node/electron';
 import { LoggerService } from 'vs/platform/log/node/loggerService';
 import { UserDataSyncLogService } from 'vs/platform/userDataSync/common/userDataSyncLog';
-import { IAuthTokenService } from 'vs/platform/auth/common/auth';
-import { AuthTokenService } from 'vs/platform/auth/electron-browser/authTokenService';
-import { AuthTokenChannel } from 'vs/platform/auth/common/authTokenIpc';
 import { ICredentialsService } from 'vs/platform/credentials/common/credentials';
 import { KeytarCredentialsService } from 'vs/platform/credentials/node/credentialsService';
 import { UserDataAutoSync } from 'vs/platform/userDataSync/electron-browser/userDataAutoSync';
+import { SettingsSynchroniser } from 'vs/platform/userDataSync/common/settingsSync';
+import { UserDataAuthTokenService } from 'vs/platform/userDataSync/common/userDataAuthTokenService';

 export interface ISharedProcessConfiguration {
 	readonly machineId: string;
@@ -182,10 +181,11 @@ async function main(server: Server, initData: ISharedProcessInitData, configurat
 		services.set(IDiagnosticsService, new SyncDescriptor(DiagnosticsService));

 		services.set(ICredentialsService, new SyncDescriptor(KeytarCredentialsService));
-		services.set(IAuthTokenService, new SyncDescriptor(AuthTokenService));
+		services.set(IUserDataAuthTokenService, new SyncDescriptor(UserDataAuthTokenService));
 		services.set(IUserDataSyncLogService, new SyncDescriptor(UserDataSyncLogService));
 		services.set(IUserDataSyncUtilService, new UserDataSyncUtilServiceClient(server.getChannel('userDataSyncUtil', activeWindowRouter)));
 		services.set(IUserDataSyncStoreService, new SyncDescriptor(UserDataSyncStoreService));
+		services.set(ISettingsSyncService, new SyncDescriptor(SettingsSynchroniser));
 		services.set(IUserDataSyncService, new SyncDescriptor(UserDataSyncService));
 		registerConfiguration();

@@ -205,14 +205,22 @@ async function main(server: Server, initData: ISharedProcessInitData, configurat
 			const diagnosticsChannel = new DiagnosticsChannel(diagnosticsService);
 			server.registerChannel('diagnostics', diagnosticsChannel);

-			const authTokenService = accessor.get(IAuthTokenService);
-			const authTokenChannel = new AuthTokenChannel(authTokenService);
+			const authTokenService = accessor.get(IUserDataAuthTokenService);
+			const authTokenChannel = new UserDataAuthTokenServiceChannel(authTokenService);
 			server.registerChannel('authToken', authTokenChannel);

+			const settingsSyncService = accessor.get(ISettingsSyncService);
+			const settingsSyncChannel = new SettingsSyncChannel(settingsSyncService);
+			server.registerChannel('settingsSync', settingsSyncChannel);
+
 			const userDataSyncService = accessor.get(IUserDataSyncService);
 			const userDataSyncChannel = new UserDataSyncChannel(userDataSyncService);
 			server.registerChannel('userDataSync', userDataSyncChannel);

+			const userDataAutoSync = instantiationService2.createInstance(UserDataAutoSync);
+			const userDataAutoSyncChannel = new UserDataAutoSyncChannel(userDataAutoSync);
+			server.registerChannel('userDataAutoSync', userDataAutoSyncChannel);
+
 			// clean up deprecated extensions
 			(extensionManagementService as ExtensionManagementService).removeDeprecatedExtensions();
 			// update localizations cache
@@ -223,7 +231,7 @@ async function main(server: Server, initData: ISharedProcessInitData, configurat
 				instantiationService2.createInstance(LanguagePackCachedDataCleaner),
 				instantiationService2.createInstance(StorageDataCleaner),
 				instantiationService2.createInstance(LogsDataCleaner),
-				instantiationService2.createInstance(UserDataAutoSync)
+				userDataAutoSync
 			));
 			disposables.add(extensionManagementService as ExtensionManagementService);
 		});
--- a/src/vs/code/electron-main/app.ts
+++ b/src/vs/code/electron-main/app.ts
@@ -171,7 +171,7 @@ export class CodeApplication extends Disposable {
 		app.on('web-contents-created', (_event: Event, contents) => {
 			contents.on('will-attach-webview', (event: Event, webPreferences, params) => {

-				const isValidWebviewSource = (source: string): boolean => {
+				const isValidWebviewSource = (source: string | undefined): boolean => {
 					if (!source) {
 						return false;
 					}
@@ -191,11 +191,12 @@ export class CodeApplication extends Disposable {
 				webPreferences.nodeIntegration = false;

 				// Verify URLs being loaded
-				if (isValidWebviewSource(params.src) && isValidWebviewSource(webPreferences.preloadURL)) {
+				// https://github.com/electron/electron/issues/21553
+				if (isValidWebviewSource(params.src) && isValidWebviewSource((webPreferences as { preloadURL: string }).preloadURL)) {
 					return;
 				}

-				delete webPreferences.preloadUrl;
+				delete (webPreferences as { preloadURL: string }).preloadURL; // https://github.com/electron/electron/issues/21553

 				// Otherwise prevent loading
 				this.logService.error('webContents#web-contents-created: Prevented webview attach');
@@ -497,27 +498,27 @@ export class CodeApplication extends Disposable {
 		this.logService.info(`Tracing: waiting for windows to get ready...`);

 		let recordingStopped = false;
-		const stopRecording = (timeout: boolean) => {
+		const stopRecording = async (timeout: boolean) => {
 			if (recordingStopped) {
 				return;
 			}

 			recordingStopped = true; // only once

-			contentTracing.stopRecording(join(homedir(), `${product.applicationName}-${Math.random().toString(16).slice(-4)}.trace.txt`), path => {
-				if (!timeout) {
-					if (this.dialogMainService) {
-						this.dialogMainService.showMessageBox({
-							type: 'info',
-							message: localize('trace.message', "Successfully created trace."),
-							detail: localize('trace.detail', "Please create an issue and manually attach the following file:\n{0}", path),
-							buttons: [localize('trace.ok', "Ok")]
-						}, withNullAsUndefined(BrowserWindow.getFocusedWindow()));
-					}
-				} else {
-					this.logService.info(`Tracing: data recorded (after 30s timeout) to ${path}`);
+			const path = await contentTracing.stopRecording(join(homedir(), `${product.applicationName}-${Math.random().toString(16).slice(-4)}.trace.txt`));
+
+			if (!timeout) {
+				if (this.dialogMainService) {
+					this.dialogMainService.showMessageBox({
+						type: 'info',
+						message: localize('trace.message', "Successfully created trace."),
+						detail: localize('trace.detail', "Please create an issue and manually attach the following file:\n{0}", path),
+						buttons: [localize('trace.ok', "Ok")]
+					}, withNullAsUndefined(BrowserWindow.getFocusedWindow()));
 				}
-			});
+			} else {
+				this.logService.info(`Tracing: data recorded (after 30s timeout) to ${path}`);
+			}
 		};

 		// Wait up to 30s before creating the trace anyways
--- a/src/vs/code/electron-main/window.ts
+++ b/src/vs/code/electron-main/window.ts
@@ -8,7 +8,7 @@ import * as objects from 'vs/base/common/objects';
 import * as nls from 'vs/nls';
 import { Event as CommonEvent, Emitter } from 'vs/base/common/event';
 import { URI } from 'vs/base/common/uri';
-import { screen, BrowserWindow, systemPreferences, app, TouchBar, nativeImage, Rectangle, Display, TouchBarSegmentedControl, NativeImage, BrowserWindowConstructorOptions, SegmentedControlSegment } from 'electron';
+import { screen, BrowserWindow, systemPreferences, app, TouchBar, nativeImage, Rectangle, Display, TouchBarSegmentedControl, NativeImage, BrowserWindowConstructorOptions, SegmentedControlSegment, nativeTheme } from 'electron';
 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';
@@ -347,9 +347,9 @@ export class CodeWindow extends Disposable implements ICodeWindow {
 		});

 		this._win.webContents.session.webRequest.onHeadersReceived(null!, (details, callback) => {
-			const responseHeaders = details.responseHeaders as { [key: string]: string[] };
+			const responseHeaders = details.responseHeaders as Record<string, (string) | (string[])>;

-			const contentType: string[] = (responseHeaders['content-type'] || responseHeaders['Content-Type']);
+			const contentType = (responseHeaders['content-type'] || responseHeaders['Content-Type']);
 			if (contentType && Array.isArray(contentType) && contentType.some(x => x.toLowerCase().indexOf('image/svg') >= 0)) {
 				return callback({ cancel: true });
 			}
@@ -441,7 +441,7 @@ export class CodeWindow extends Disposable implements ICodeWindow {
 		// Inject headers when requests are incoming
 		const urls = ['https://marketplace.visualstudio.com/*', 'https://*.vsassets.io/*'];
 		this._win.webContents.session.webRequest.onBeforeSendHeaders({ urls }, (details, cb) =>
-			this.marketplaceHeadersPromise.then(headers => cb({ cancel: false, requestHeaders: objects.assign(details.requestHeaders, headers) as { [key: string]: string | undefined } })));
+			this.marketplaceHeadersPromise.then(headers => cb({ cancel: false, requestHeaders: objects.assign(details.requestHeaders, headers) as Record<string, string> })));
 	}

 	private onWindowError(error: WindowError): void {
@@ -648,7 +648,7 @@ export class CodeWindow extends Disposable implements ICodeWindow {
 		if (windowConfig?.autoDetectHighContrast === false) {
 			autoDetectHighContrast = false;
 		}
-		windowConfiguration.highContrast = isWindows && autoDetectHighContrast && systemPreferences.isInvertedColorScheme();
+		windowConfiguration.highContrast = isWindows && autoDetectHighContrast && nativeTheme.shouldUseInvertedColorScheme;
 		windowConfiguration.accessibilitySupport = app.accessibilitySupportEnabled;

 		// Title style related
@@ -1007,22 +1007,22 @@ export class CodeWindow extends Disposable implements ICodeWindow {
 		switch (visibility) {
 			case ('default'):
 				this._win.setMenuBarVisibility(!isFullscreen);
-				this._win.setAutoHideMenuBar(isFullscreen);
+				this._win.autoHideMenuBar = isFullscreen;
 				break;

 			case ('visible'):
 				this._win.setMenuBarVisibility(true);
-				this._win.setAutoHideMenuBar(false);
+				this._win.autoHideMenuBar = false;
 				break;

 			case ('toggle'):
 				this._win.setMenuBarVisibility(false);
-				this._win.setAutoHideMenuBar(true);
+				this._win.autoHideMenuBar = true;
 				break;

 			case ('hidden'):
 				this._win.setMenuBarVisibility(false);
-				this._win.setAutoHideMenuBar(false);
+				this._win.autoHideMenuBar = false;
 				break;
 		}
 	}
--- a/src/vs/code/node/cli.ts
+++ b/src/vs/code/node/cli.ts
@@ -14,10 +14,10 @@ import product from 'vs/platform/product/common/product';
 import * as paths from 'vs/base/common/path';
 import { whenDeleted, writeFileSync } from 'vs/base/node/pfs';
 import { findFreePort, randomPort } from 'vs/base/node/ports';
-import { resolveTerminalEncoding } from 'vs/base/node/encoding';
 import { isWindows, isLinux } from 'vs/base/common/platform';
 import { ProfilingSession, Target } from 'v8-inspect-profiler';
 import { isString } from 'vs/base/common/types';
+import { hasStdinWithoutTty, stdinDataListener, getStdinFilePath, readFromStdin } from 'vs/platform/environment/node/stdin';

 function shouldSpawnCliProcess(argv: ParsedArgs): boolean {
 	return !!argv['install-source']
@@ -142,91 +142,55 @@ export async function main(argv: string[]): Promise<any> {
 			});
 		}

-		let stdinWithoutTty: boolean = false;
-		try {
-			stdinWithoutTty = !process.stdin.isTTY; // Via https://twitter.com/MylesBorins/status/782009479382626304
-		} catch (error) {
-			// Windows workaround for https://github.com/nodejs/node/issues/11656
-		}
-
-		const readFromStdin = args._.some(a => a === '-');
-		if (readFromStdin) {
+		const hasReadStdinArg = args._.some(a => a === '-');
+		if (hasReadStdinArg) {
 			// remove the "-" argument when we read from stdin
 			args._ = args._.filter(a => a !== '-');
 			argv = argv.filter(a => a !== '-');
 		}

-		let stdinFilePath: string;
-		if (stdinWithoutTty) {
+		let stdinFilePath: string | undefined;
+		if (hasStdinWithoutTty()) {

 			// Read from stdin: we require a single "-" argument to be passed in order to start reading from
 			// stdin. We do this because there is no reliable way to find out if data is piped to stdin. Just
 			// checking for stdin being connected to a TTY is not enough (https://github.com/Microsoft/vscode/issues/40351)
-			if (args._.length === 0 && readFromStdin) {

-				// prepare temp file to read stdin to
-				stdinFilePath = paths.join(os.tmpdir(), `code-stdin-${Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 3)}.txt`);
+			if (args._.length === 0) {
+				if (hasReadStdinArg) {
+					stdinFilePath = getStdinFilePath();

-				// open tmp file for writing
-				let stdinFileError: Error | undefined;
-				let stdinFileStream: fs.WriteStream;
-				try {
-					stdinFileStream = fs.createWriteStream(stdinFilePath);
-				} catch (error) {
-					stdinFileError = error;
-				}
+					// returns a file path where stdin input is written into (write in progress).
+					try {
+						readFromStdin(stdinFilePath, !!verbose); // throws error if file can not be written

-				if (!stdinFileError) {
+						// Make sure to open tmp file
+						addArg(argv, stdinFilePath);

-					// Pipe into tmp file using terminals encoding
-					resolveTerminalEncoding(verbose).then(async encoding => {
-						const iconv = await import('iconv-lite');
-						const converterStream = iconv.decodeStream(encoding);
-						process.stdin.pipe(converterStream).pipe(stdinFileStream);
-					});
+						// Enable --wait to get all data and ignore adding this to history
+						addArg(argv, '--wait');
+						addArg(argv, '--skip-add-to-recently-opened');
+						args.wait = true;

-					// Make sure to open tmp file
-					addArg(argv, stdinFilePath);
-
-					// Enable --wait to get all data and ignore adding this to history
-					addArg(argv, '--wait');
-					addArg(argv, '--skip-add-to-recently-opened');
-					args.wait = true;
-				}
-
-				if (verbose) {
-					if (stdinFileError) {
-						console.error(`Failed to create file to read via stdin: ${stdinFileError.toString()}`);
-					} else {
 						console.log(`Reading from stdin via: ${stdinFilePath}`);
+					} catch (e) {
+						console.log(`Failed to create file to read via stdin: ${e.toString()}`);
+						stdinFilePath = undefined;
 					}
-				}
-			}
+				} else {

-			// If the user pipes data via stdin but forgot to add the "-" argument, help by printing a message
-			// if we detect that data flows into via stdin after a certain timeout.
-			else if (args._.length === 0) {
-				processCallbacks.push(child => new Promise(c => {
-					const dataListener = () => {
-						if (isWindows) {
-							console.log(`Run with '${product.applicationName} -' to read output from another program (e.g. 'echo Hello World | ${product.applicationName} -').`);
-						} else {
-							console.log(`Run with '${product.applicationName} -' to read from stdin (e.g. 'ps aux | grep code | ${product.applicationName} -').`);
+					// If the user pipes data via stdin but forgot to add the "-" argument, help by printing a message
+					// if we detect that data flows into via stdin after a certain timeout.
+					processCallbacks.push(_ => stdinDataListener(1000).then(dataReceived => {
+						if (dataReceived) {
+							if (isWindows) {
+								console.log(`Run with '${product.applicationName} -' to read output from another program (e.g. 'echo Hello World | ${product.applicationName} -').`);
+							} else {
+								console.log(`Run with '${product.applicationName} -' to read from stdin (e.g. 'ps aux | grep code | ${product.applicationName} -').`);
+							}
 						}
-
-						c(undefined);
-					};
-
-					// wait for 1s maximum...
-					setTimeout(() => {
-						process.stdin.removeListener('data', dataListener);
-
-						c(undefined);
-					}, 1000);
-
-					// ...but finish early if we detect data
-					process.stdin.once('data', dataListener);
-				}));
+					}));
+				}
 			}
 		}