#103405 check if sync is on

src/vs/workbench/contrib/extensions/browser/extensionsActions.ts

@@ -909,7 +909,7 @@ export class EnableForWorkspaceAction extends ExtensionAction {
 		if (this.extension && this.extension.local) {
 			this.enabled = this.extension.state === ExtensionState.Installed
 				&& !this.extensionEnablementService.isEnabled(this.extension.local)
-				&& this.extensionEnablementService.canChangeEnablement(this.extension.local);
+				&& this.extensionEnablementService.canChangeWorkspaceEnablement(this.extension.local);
 		}
 	}
 

src/vs/workbench/contrib/userDataSync/browser/userDataAutoSyncService.ts

-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { IUserDataSyncService, IUserDataSyncLogService, IUserDataSyncResourceEnablementService, IUserDataSyncStoreService, IUserDataSyncStoreManagementService } from 'vs/platform/userDataSync/common/userDataSync';
-import { Event } from 'vs/base/common/event';
-import { UserDataAutoSyncService as BaseUserDataAutoSyncService } from 'vs/platform/userDataSync/common/userDataAutoSyncService';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { IHostService } from 'vs/workbench/services/host/browser/host';
-import { IUserDataSyncAccountService } from 'vs/platform/userDataSync/common/userDataSyncAccount';
-import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
-import { UserDataSyncTrigger } from 'vs/workbench/contrib/userDataSync/browser/userDataSyncTrigger';
-import { IStorageService } from 'vs/platform/storage/common/storage';
-import { IEnvironmentService } from 'vs/platform/environment/common/environment';
-import { IUserDataSyncMachinesService } from 'vs/platform/userDataSync/common/userDataSyncMachines';
-
-export class UserDataAutoSyncService extends BaseUserDataAutoSyncService {
-
-	constructor(
-		@IUserDataSyncStoreManagementService userDataSyncStoreManagementService: IUserDataSyncStoreManagementService,
-		@IUserDataSyncStoreService userDataSyncStoreService: IUserDataSyncStoreService,
-		@IUserDataSyncResourceEnablementService userDataSyncResourceEnablementService: IUserDataSyncResourceEnablementService,
-		@IUserDataSyncService userDataSyncService: IUserDataSyncService,
-		@IUserDataSyncLogService logService: IUserDataSyncLogService,
-		@IUserDataSyncAccountService authTokenService: IUserDataSyncAccountService,
-		@IInstantiationService instantiationService: IInstantiationService,
-		@IHostService hostService: IHostService,
-		@ITelemetryService telemetryService: ITelemetryService,
-		@IUserDataSyncMachinesService userDataSyncMachinesService: IUserDataSyncMachinesService,
-		@IStorageService storageService: IStorageService,
-		@IEnvironmentService environmentService: IEnvironmentService,
-	) {
-		super(userDataSyncStoreManagementService, userDataSyncStoreService, userDataSyncResourceEnablementService, userDataSyncService, logService, authTokenService, telemetryService, userDataSyncMachinesService, storageService, environmentService);
-
-		this._register(Event.debounce<string, string[]>(Event.any<string>(
-			Event.map(hostService.onDidChangeFocus, () => 'windowFocus'),
-			instantiationService.createInstance(UserDataSyncTrigger).onDidTriggerSync,
-		), (last, source) => last ? [...last, source] : [source], 1000)(sources => this.triggerSync(sources, true, false)));
-	}
-
-}

src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.ts

@@ -13,6 +13,7 @@ import { Disposable } from 'vs/base/common/lifecycle';
 import { localize } from 'vs/nls';
 import { isWeb } from 'vs/base/common/platform';
 import { IConfigurationService, ConfigurationTarget } from 'vs/platform/configuration/common/configuration';
+import { UserDataSyncTrigger } from 'vs/workbench/contrib/userDataSync/browser/userDataSyncTrigger';
 
 class UserDataSyncReportIssueContribution extends Disposable implements IWorkbenchContribution {
 
@@ -67,6 +68,7 @@ export class UserDataSyncSettingsMigrationContribution implements IWorkbenchCont
 const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench);
 workbenchRegistry.registerWorkbenchContribution(UserDataSyncWorkbenchContribution, LifecyclePhase.Ready);
 workbenchRegistry.registerWorkbenchContribution(UserDataSyncSettingsMigrationContribution, LifecyclePhase.Eventually);
+workbenchRegistry.registerWorkbenchContribution(UserDataSyncTrigger, LifecyclePhase.Eventually);
 
 if (isWeb) {
 	workbenchRegistry.registerWorkbenchContribution(UserDataSyncReportIssueContribution, LifecyclePhase.Ready);

src/vs/workbench/contrib/userDataSync/browser/userDataSyncTrigger.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Event, Emitter } from 'vs/base/common/event';
+import { Event } from 'vs/base/common/event';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { SettingsEditor2Input, KeybindingsEditorInput, PreferencesEditorInput } from 'vs/workbench/services/preferences/common/preferencesEditorInput';
@@ -12,24 +12,36 @@ import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/
 import { VIEWLET_ID } from 'vs/workbench/contrib/extensions/common/extensions';
 import { IEditorInput } from 'vs/workbench/common/editor';
 import { IViewsService } from 'vs/workbench/common/views';
+import { IUserDataAutoSyncService } from 'vs/platform/userDataSync/common/userDataSync';
+import { IWorkbenchContribution } from 'vs/workbench/common/contributions';
+import { isWeb } from 'vs/base/common/platform';
+import { IHostService } from 'vs/workbench/services/host/browser/host';
 
-export class UserDataSyncTrigger extends Disposable {
-
-	private readonly _onDidTriggerSync: Emitter<string> = this._register(new Emitter<string>());
-	readonly onDidTriggerSync: Event<string> = this._onDidTriggerSync.event;
+export class UserDataSyncTrigger extends Disposable implements IWorkbenchContribution {
 
 	constructor(
 		@IEditorService editorService: IEditorService,
 		@IWorkbenchEnvironmentService private readonly workbenchEnvironmentService: IWorkbenchEnvironmentService,
 		@IViewsService viewsService: IViewsService,
+		@IUserDataAutoSyncService userDataAutoSyncService: IUserDataAutoSyncService,
+		@IHostService hostService: IHostService,
 	) {
 		super();
-		this._register(
-			Event.filter(
-				Event.any<string | undefined>(
-					Event.map(editorService.onDidActiveEditorChange, () => this.getUserDataEditorInputSource(editorService.activeEditor)),
-					Event.map(Event.filter(viewsService.onDidChangeViewContainerVisibility, e => e.id === VIEWLET_ID && e.visible), e => e.id)
-				), source => source !== undefined)(source => this._onDidTriggerSync.fire(source!)));
+		const event = Event.filter(
+			Event.any<string | undefined>(
+				Event.map(editorService.onDidActiveEditorChange, () => this.getUserDataEditorInputSource(editorService.activeEditor)),
+				Event.map(Event.filter(viewsService.onDidChangeViewContainerVisibility, e => e.id === VIEWLET_ID && e.visible), e => e.id)
+			), source => source !== undefined);
+		if (isWeb) {
+			this._register(Event.debounce<string, string[]>(
+				Event.any<string>(
+					Event.map(hostService.onDidChangeFocus, () => 'windowFocus'),
+					Event.map(event, source => source!),
+				), (last, source) => last ? [...last, source] : [source], 1000)
+				(sources => userDataAutoSyncService.triggerSync(sources, true, false)));
+		} else {
+			this._register(event(source => userDataAutoSyncService.triggerSync([source!], true, false)));
+		}
 	}
 
 	private getUserDataEditorInputSource(editorInput: IEditorInput | undefined): string | undefined {

src/vs/workbench/services/extensionManagement/common/extensionEnablementService.ts

@@ -20,6 +20,7 @@ import { IProductService } from 'vs/platform/product/common/productService';
 import { StorageManager } from 'vs/platform/extensionManagement/common/extensionEnablementService';
 import { webWorkerExtHostConfig } from 'vs/workbench/services/extensions/common/extensions';
 import { IUserDataSyncAccountService } from 'vs/platform/userDataSync/common/userDataSyncAccount';
+import { IUserDataAutoSyncService } from 'vs/platform/userDataSync/common/userDataSync';
 
 const SOURCE = 'IWorkbenchExtensionEnablementService';
 
@@ -41,6 +42,7 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 		@IConfigurationService private readonly configurationService: IConfigurationService,
 		@IExtensionManagementServerService private readonly extensionManagementServerService: IExtensionManagementServerService,
 		@IProductService private readonly productService: IProductService,
+		@IUserDataAutoSyncService private readonly userDataAutoSyncService: IUserDataAutoSyncService,
 		@IUserDataSyncAccountService private readonly userDataSyncAccountService: IUserDataSyncAccountService,
 	) {
 		super();
@@ -85,7 +87,7 @@ export class ExtensionEnablementService extends Disposable implements IWorkbench
 			throw new Error(localize('cannot disable language pack extension', "Cannot disable {0} extension because it contributes language packs.", extension.manifest.displayName || extension.identifier.id));
 		}
 
-		if (this.userDataSyncAccountService.account &&
+		if (this.userDataAutoSyncService.isEnabled() && this.userDataSyncAccountService.account &&
 			isAuthenticaionProviderExtension(extension.manifest) && extension.manifest.contributes!.authentication!.some(a => a.id === this.userDataSyncAccountService.account!.authenticationProviderId)) {
 			throw new Error(localize('cannot disable auth extension', "Cannot disable {0} extension because Settings Sync depends on it.", extension.manifest.displayName || extension.identifier.id));
 		}

src/vs/workbench/services/extensionManagement/test/browser/extensionEnablementService.test.ts

@@ -24,6 +24,7 @@ import { TestConfigurationService } from 'vs/platform/configuration/test/common/
 import { productService } from 'vs/workbench/test/browser/workbenchTestServices';
 import { GlobalExtensionEnablementService } from 'vs/platform/extensionManagement/common/extensionEnablementService';
 import { IUserDataSyncAccountService, UserDataSyncAccountService } from 'vs/platform/userDataSync/common/userDataSyncAccount';
+import { IUserDataAutoSyncService } from 'vs/platform/userDataSync/common/userDataSync';
 
 function createStorageService(instantiationService: TestInstantiationService): IStorageService {
 	let service = instantiationService.get(IStorageService);
@@ -53,6 +54,7 @@ export class TestExtensionEnablementService extends ExtensionEnablementService {
 			instantiationService.get(IConfigurationService),
 			extensionManagementServerService,
 			productService,
+			instantiationService.get(IUserDataAutoSyncService) || instantiationService.stub(IUserDataAutoSyncService, <Partial<IUserDataAutoSyncService>>{ isEnabled() { return false; } }),
 			instantiationService.get(IUserDataSyncAccountService) || instantiationService.stub(IUserDataSyncAccountService, UserDataSyncAccountService)
 		);
 	}
@@ -385,7 +387,16 @@ suite('ExtensionEnablementService Test', () => {
 		assert.equal(testObject.canChangeEnablement(aLocalExtension('pub.a', { authentication: [{ id: 'a', label: 'a' }] })), true);
 	});
 
-	test('test canChangeEnablement return false for auth extension and user data sync account depends on it', () => {
+	test('test canChangeEnablement return true for auth extension when user data sync account depends on it but auto sync is off', () => {
+		instantiationService.stub(IUserDataSyncAccountService, <Partial<IUserDataSyncAccountService>>{
+			account: { authenticationProviderId: 'a' }
+		});
+		testObject = new TestExtensionEnablementService(instantiationService);
+		assert.equal(testObject.canChangeEnablement(aLocalExtension('pub.a', { authentication: [{ id: 'a', label: 'a' }] })), true);
+	});
+
+	test('test canChangeEnablement return false for auth extension and user data sync account depends on it and auto sync is on', () => {
+		instantiationService.stub(IUserDataAutoSyncService, <Partial<IUserDataAutoSyncService>>{ isEnabled() { return true; } });
 		instantiationService.stub(IUserDataSyncAccountService, <Partial<IUserDataSyncAccountService>>{
 			account: { authenticationProviderId: 'a' }
 		});

src/vs/workbench/contrib/userDataSync/electron-browser/userDataAutoSyncService.ts → src/vs/workbench/services/userDataSync/electron-browser/userDataAutoSyncService.ts

@@ -7,13 +7,12 @@ import { IUserDataAutoSyncService, UserDataSyncError, IUserDataSyncStoreManageme
 import { ISharedProcessService } from 'vs/platform/ipc/electron-browser/sharedProcessService';
 import { IChannel } from 'vs/base/parts/ipc/common/ipc';
 import { Event } from 'vs/base/common/event';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { UserDataSyncTrigger } from 'vs/workbench/contrib/userDataSync/browser/userDataSyncTrigger';
 import { UserDataAutoSyncEnablementService } from 'vs/platform/userDataSync/common/userDataAutoSyncService';
 import { IStorageService } from 'vs/platform/storage/common/storage';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 
-export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService implements IUserDataAutoSyncService {
+class UserDataAutoSyncService extends UserDataAutoSyncEnablementService implements IUserDataAutoSyncService {
 
 	declare readonly _serviceBrand: undefined;
 
@@ -24,12 +23,10 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i
 		@IStorageService storageService: IStorageService,
 		@IEnvironmentService environmentService: IEnvironmentService,
 		@IUserDataSyncStoreManagementService userDataSyncStoreManagementService: IUserDataSyncStoreManagementService,
-		@IInstantiationService instantiationService: IInstantiationService,
 		@ISharedProcessService sharedProcessService: ISharedProcessService,
 	) {
 		super(storageService, environmentService, userDataSyncStoreManagementService);
 		this.channel = sharedProcessService.getChannel('userDataAutoSync');
-		this._register(instantiationService.createInstance(UserDataSyncTrigger).onDidTriggerSync(source => this.triggerSync([source], true, false)));
 	}
 
 	triggerSync(sources: string[], hasToLimitSync: boolean, disableCache: boolean): Promise<void> {
@@ -45,3 +42,5 @@ export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService i
 	}
 
 }
+
+registerSingleton(IUserDataAutoSyncService, UserDataAutoSyncService);

src/vs/workbench/contrib/userDataSync/electron-browser/userDataSyncStoreManagementService.ts → src/vs/workbench/services/userDataSync/electron-browser/userDataSyncStoreManagementService.ts

@@ -11,8 +11,9 @@ import { AbstractUserDataSyncStoreManagementService } from 'vs/platform/userData
 import { IProductService } from 'vs/platform/product/common/productService';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { URI } from 'vs/base/common/uri';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 
-export class UserDataSyncStoreManagementService extends AbstractUserDataSyncStoreManagementService implements IUserDataSyncStoreManagementService {
+class UserDataSyncStoreManagementService extends AbstractUserDataSyncStoreManagementService implements IUserDataSyncStoreManagementService {
 
 	private readonly channel: IChannel;
 
@@ -46,3 +47,5 @@ export class UserDataSyncStoreManagementService extends AbstractUserDataSyncStor
 	}
 
 }
+
+registerSingleton(IUserDataSyncStoreManagementService, UserDataSyncStoreManagementService);

src/vs/workbench/workbench.desktop.main.ts

@@ -55,6 +55,8 @@ import 'vs/workbench/services/workspaces/electron-browser/workspaceEditingServic
 import 'vs/workbench/services/userDataSync/electron-browser/userDataSyncMachinesService';
 import 'vs/workbench/services/userDataSync/electron-browser/userDataSyncService';
 import 'vs/workbench/services/userDataSync/electron-browser/userDataSyncAccountService';
+import 'vs/workbench/services/userDataSync/electron-browser/userDataSyncStoreManagementService';
+import 'vs/workbench/services/userDataSync/electron-browser/userDataAutoSyncService';
 import 'vs/workbench/services/sharedProcess/electron-browser/sharedProcessService';
 import 'vs/workbench/services/localizations/electron-browser/localizationsService';
 import 'vs/workbench/services/path/electron-browser/pathService';
@@ -63,8 +65,6 @@ import 'vs/workbench/services/experiment/electron-browser/experimentService';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { ICredentialsService } from 'vs/platform/credentials/common/credentials';
 import { KeytarCredentialsService } from 'vs/platform/credentials/node/credentialsService';
-import { IUserDataAutoSyncService, IUserDataSyncStoreManagementService } from 'vs/platform/userDataSync/common/userDataSync';
-import { UserDataAutoSyncService } from 'vs/workbench/contrib/userDataSync/electron-browser/userDataAutoSyncService';
 import { ITunnelService } from 'vs/platform/remote/common/tunnel';
 import { TunnelService } from 'vs/platform/remote/node/tunnelService';
 import { ITimerService } from 'vs/workbench/services/timer/browser/timerService';
@@ -72,8 +72,6 @@ import { TimerService } from 'vs/workbench/services/timer/electron-browser/timer
 import { IUserDataInitializationService, UserDataInitializationService } from 'vs/workbench/services/userData/browser/userDataInit';
 
 registerSingleton(ICredentialsService, KeytarCredentialsService, true);
-registerSingleton(IUserDataSyncStoreManagementService, UserDataSyncStoreManagementService);
-registerSingleton(IUserDataAutoSyncService, UserDataAutoSyncService);
 registerSingleton(ITunnelService, TunnelService);
 registerSingleton(ITimerService, TimerService);
 registerSingleton(IUserDataInitializationService, UserDataInitializationService);
@@ -137,6 +135,5 @@ import 'vs/workbench/contrib/userDataSync/electron-browser/userDataSync.contribu
 
 // Configuration Exporter
 import 'vs/workbench/contrib/configExporter/electron-browser/configurationExportHelper.contribution';
-import { UserDataSyncStoreManagementService } from 'vs/workbench/contrib/userDataSync/electron-browser/userDataSyncStoreManagementService';
 
 //#endregion

src/vs/workbench/workbench.web.main.ts

@@ -71,7 +71,7 @@ import { UserDataSyncStoreService, UserDataSyncStoreManagementService } from 'vs
 import { UserDataSyncBackupStoreService } from 'vs/platform/userDataSync/common/userDataSyncBackupStoreService';
 import { UserDataSyncService } from 'vs/platform/userDataSync/common/userDataSyncService';
 import { IUserDataSyncAccountService, UserDataSyncAccountService } from 'vs/platform/userDataSync/common/userDataSyncAccount';
-import { UserDataAutoSyncService } from 'vs/workbench/contrib/userDataSync/browser/userDataAutoSyncService';
+import { UserDataAutoSyncService } from 'vs/platform/userDataSync/common/userDataAutoSyncService';
 import { AccessibilityService } from 'vs/platform/accessibility/common/accessibilityService';
 import { ITitleService } from 'vs/workbench/services/title/common/titleService';
 import { TitlebarPart } from 'vs/workbench/browser/parts/titlebar/titlebarPart';
@@ -90,8 +90,8 @@ registerSingleton(IUserDataSyncMachinesService, UserDataSyncMachinesService);
 registerSingleton(IUserDataSyncBackupStoreService, UserDataSyncBackupStoreService);
 registerSingleton(IStorageKeysSyncRegistryService, StorageKeysSyncRegistryService);
 registerSingleton(IUserDataSyncAccountService, UserDataSyncAccountService);
-registerSingleton(IUserDataAutoSyncService, UserDataAutoSyncService);
-registerSingleton(IUserDataSyncService, UserDataSyncService);
+registerSingleton(IUserDataSyncService, UserDataSyncService, true);
+registerSingleton(IUserDataAutoSyncService, UserDataAutoSyncService, true);
 registerSingleton(ITitleService, TitlebarPart);
 registerSingleton(IExtensionTipsService, ExtensionTipsService);
 registerSingleton(ITimerService, TimerService);