get store details from settings

src/vs/platform/product/common/productService.ts

@@ -102,12 +102,6 @@ export interface IProductConfiguration {
 
 	readonly msftInternalDomains?: string[];
 	readonly linkProtectionTrustedDomains?: readonly string[];
-
-	readonly settingsSyncStore?: {
-		url: string;
-		name: string;
-		account: string;
-	};
 }
 
 export interface IExeBasedExtensionTip {

src/vs/platform/userDataSync/common/userDataSync.ts

@@ -14,8 +14,12 @@ import { IDisposable } from 'vs/base/common/lifecycle';
 import { IJSONContributionRegistry, Extensions as JSONExtensions } from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
 import { IJSONSchema } from 'vs/base/common/jsonSchema';
 import { ILogService } from 'vs/platform/log/common/log';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+
+const CONFIGURATION_SYNC_STORE_KEY = 'configurationSync.store';
 
 export const DEFAULT_IGNORED_SETTINGS = [
+	CONFIGURATION_SYNC_STORE_KEY,
 	'configurationSync.enable',
 	'configurationSync.enableSettings',
 	'configurationSync.enableExtensions',
@@ -98,12 +102,23 @@ export class UserDataSyncStoreError extends Error {
 
 }
 
+export interface IUserDataSyncStore {
+	url: string;
+	name: string;
+	account: string;
+}
+
+export function getUserDataSyncStore(configurationService: IConfigurationService): IUserDataSyncStore | undefined {
+	const value = configurationService.getValue<IUserDataSyncStore>(CONFIGURATION_SYNC_STORE_KEY);
+	return value && value.url && value.name && value.account ? value : undefined;
+}
+
 export const IUserDataSyncStoreService = createDecorator<IUserDataSyncStoreService>('IUserDataSyncStoreService');
 
 export interface IUserDataSyncStoreService {
 	_serviceBrand: undefined;
 
-	readonly enabled: boolean;
+	readonly userDataSyncStore: IUserDataSyncStore | undefined;
 
 	read(key: string, oldValue: IUserData | null): Promise<IUserData>;
 	write(key: string, content: string, ref: string | null): Promise<string>;

src/vs/platform/userDataSync/common/userDataSyncService.ts

@@ -44,7 +44,7 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
 		this.synchronisers = [this.settingsSynchroniser, this.extensionsSynchroniser];
 		this.updateStatus();
 
-		if (this.userDataSyncStoreService.enabled) {
+		if (this.userDataSyncStoreService.userDataSyncStore) {
 			this._register(Event.any(...this.synchronisers.map(s => Event.map(s.onDidChangeStatus, () => undefined)))(() => this.updateStatus()));
 			this._register(authTokenService.onDidChangeStatus(() => this.onDidChangeAuthTokenStatus()));
 		}
@@ -53,7 +53,7 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
 	}
 
 	async sync(_continue?: boolean): Promise<boolean> {
-		if (!this.userDataSyncStoreService.enabled) {
+		if (!this.userDataSyncStoreService.userDataSyncStore) {
 			throw new Error('Not enabled');
 		}
 		if (this.authTokenService.status === AuthTokenStatus.SignedOut) {
@@ -68,7 +68,7 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
 	}
 
 	stop(): void {
-		if (!this.userDataSyncStoreService.enabled) {
+		if (!this.userDataSyncStoreService.userDataSyncStore) {
 			throw new Error('Not enabled');
 		}
 		for (const synchroniser of this.synchronisers) {
@@ -93,7 +93,7 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
 	}
 
 	private computeStatus(): SyncStatus {
-		if (!this.userDataSyncStoreService.enabled) {
+		if (!this.userDataSyncStoreService.userDataSyncStore) {
 			return SyncStatus.Uninitialized;
 		}
 		if (this.synchronisers.some(s => s.status === SyncStatus.HasConflicts)) {

src/vs/platform/userDataSync/common/userDataSyncStoreService.ts

@@ -4,35 +4,36 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Disposable, } from 'vs/base/common/lifecycle';
-import { IUserData, IUserDataSyncStoreService, UserDataSyncStoreErrorCode, UserDataSyncStoreError } from 'vs/platform/userDataSync/common/userDataSync';
-import { IProductService } from 'vs/platform/product/common/productService';
+import { IUserData, IUserDataSyncStoreService, UserDataSyncStoreErrorCode, UserDataSyncStoreError, IUserDataSyncStore, getUserDataSyncStore } from 'vs/platform/userDataSync/common/userDataSync';
 import { IRequestService, asText, isSuccess } from 'vs/platform/request/common/request';
 import { URI } from 'vs/base/common/uri';
 import { joinPath } from 'vs/base/common/resources';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { IHeaders, IRequestOptions, IRequestContext } from 'vs/base/parts/request/common/request';
 import { IAuthTokenService } from 'vs/platform/auth/common/auth';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 
 export class UserDataSyncStoreService extends Disposable implements IUserDataSyncStoreService {
 
 	_serviceBrand: any;
 
-	get enabled(): boolean { return !!this.productService.settingsSyncStore; }
+	readonly userDataSyncStore: IUserDataSyncStore | undefined;
 
 	constructor(
-		@IProductService private readonly productService: IProductService,
+		@IConfigurationService configurationService: IConfigurationService,
 		@IRequestService private readonly requestService: IRequestService,
 		@IAuthTokenService private readonly authTokenService: IAuthTokenService,
 	) {
 		super();
+		this.userDataSyncStore = getUserDataSyncStore(configurationService);
 	}
 
 	async read(key: string, oldValue: IUserData | null): Promise<IUserData> {
-		if (!this.enabled) {
+		if (!this.userDataSyncStore) {
 			throw new Error('No settings sync store url configured.');
 		}
 
-		const url = joinPath(URI.parse(this.productService.settingsSyncStore!.url), 'resource', key, 'latest').toString();
+		const url = joinPath(URI.parse(this.userDataSyncStore.url), 'resource', key, 'latest').toString();
 		const headers: IHeaders = {};
 		if (oldValue) {
 			headers['If-None-Match'] = oldValue.ref;
@@ -58,11 +59,11 @@ export class UserDataSyncStoreService extends Disposable implements IUserDataSyn
 	}
 
 	async write(key: string, data: string, ref: string | null): Promise<string> {
-		if (!this.enabled) {
+		if (!this.userDataSyncStore) {
 			throw new Error('No settings sync store url configured.');
 		}
 
-		const url = joinPath(URI.parse(this.productService.settingsSyncStore!.url), 'resource', key).toString();
+		const url = joinPath(URI.parse(this.userDataSyncStore.url), 'resource', key).toString();
 		const headers: IHeaders = { 'Content-Type': 'text/plain' };
 		if (ref) {
 			headers['If-Match'] = ref;

src/vs/workbench/contrib/logs/common/logs.contribution.ts

@@ -22,7 +22,6 @@ import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
 import { isWeb } from 'vs/base/common/platform';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { LogsDataCleaner } from 'vs/workbench/contrib/logs/common/logsDataCleaner';
-import { IProductService } from 'vs/platform/product/common/productService';
 
 const workbenchActionsRegistry = Registry.as<IWorkbenchActionRegistry>(WorkbenchActionExtensions.WorkbenchActions);
 const devCategory = nls.localize('developer', "Developer");
@@ -35,7 +34,6 @@ class LogOutputChannels extends Disposable implements IWorkbenchContribution {
 		@ILogService private readonly logService: ILogService,
 		@IFileService private readonly fileService: IFileService,
 		@IInstantiationService private readonly instantiationService: IInstantiationService,
-		@IProductService private readonly productService: IProductService
 	) {
 		super();
 		this.registerCommonContributions();
@@ -47,9 +45,7 @@ class LogOutputChannels extends Disposable implements IWorkbenchContribution {
 	}
 
 	private registerCommonContributions(): void {
-		if (this.productService.settingsSyncStore) {
-			this.registerLogChannel(Constants.userDataSyncLogChannelId, nls.localize('userDataSyncLog', "Configuration Sync"), this.environmentService.userDataSyncLogResource);
-		}
+		this.registerLogChannel(Constants.userDataSyncLogChannelId, nls.localize('userDataSyncLog', "Configuration Sync"), this.environmentService.userDataSyncLogResource);
 		this.registerLogChannel(Constants.rendererLogChannelId, nls.localize('rendererLog', "Window"), this.environmentService.logFile);
 	}
 

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

@@ -3,42 +3,10 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions, IWorkbenchContribution } from 'vs/workbench/common/contributions';
-import { registerConfiguration } from 'vs/platform/userDataSync/common/userDataSync';
-import { Disposable } from 'vs/base/common/lifecycle';
+import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions } from 'vs/workbench/common/contributions';
 import { Registry } from 'vs/platform/registry/common/platform';
 import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { isWeb } from 'vs/base/common/platform';
-import { UserDataAutoSync } from 'vs/platform/userDataSync/common/userDataSyncService';
-import { IProductService } from 'vs/platform/product/common/productService';
 import { UserDataSyncWorkbenchContribution } from 'vs/workbench/contrib/userDataSync/browser/userDataSync';
 
-class UserDataSyncConfigurationContribution implements IWorkbenchContribution {
-
-	constructor(
-		@IProductService productService: IProductService
-	) {
-		if (productService.settingsSyncStore) {
-			registerConfiguration();
-		}
-	}
-}
-
-class UserDataAutoSyncContribution extends Disposable implements IWorkbenchContribution {
-
-	constructor(
-		@IInstantiationService instantiationService: IInstantiationService
-	) {
-		super();
-		if (isWeb) {
-			instantiationService.createInstance(UserDataAutoSync);
-		}
-	}
-}
-
-
 const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench);
-workbenchRegistry.registerWorkbenchContribution(UserDataSyncConfigurationContribution, LifecyclePhase.Starting);
-workbenchRegistry.registerWorkbenchContribution(UserDataSyncWorkbenchContribution, LifecyclePhase.Restored);
-workbenchRegistry.registerWorkbenchContribution(UserDataAutoSyncContribution, LifecyclePhase.Restored);
+workbenchRegistry.registerWorkbenchContribution(UserDataSyncWorkbenchContribution, LifecyclePhase.Ready);

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IWorkbenchContribution } from 'vs/workbench/common/contributions';
-import { IUserDataSyncService, SyncStatus, SyncSource, CONTEXT_SYNC_STATE } from 'vs/platform/userDataSync/common/userDataSync';
+import { IUserDataSyncService, SyncStatus, SyncSource, CONTEXT_SYNC_STATE, IUserDataSyncStore, registerConfiguration, getUserDataSyncStore } from 'vs/platform/userDataSync/common/userDataSync';
 import { localize } from 'vs/nls';
 import { Disposable, MutableDisposable, toDisposable, DisposableStore } from 'vs/base/common/lifecycle';
 import { CommandsRegistry } from 'vs/platform/commands/common/commands';
@@ -29,7 +29,9 @@ import { IDialogService } from 'vs/platform/dialogs/common/dialogs';
 import { FalseContext } from 'vs/platform/contextkey/common/contextkeys';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import { IQuickInputService } from 'vs/platform/quickinput/common/quickInput';
-import { IProductService } from 'vs/platform/product/common/productService';
+import { isWeb } from 'vs/base/common/platform';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { UserDataAutoSync } from 'vs/platform/userDataSync/common/userDataSyncService';
 
 const CONTEXT_AUTH_TOKEN_STATE = new RawContextKey<string>('authTokenStatus', AuthTokenStatus.SignedOut);
 const SYNC_PUSH_LIGHT_ICON_URI = URI.parse(registerAndGetAmdImageURL(`vs/workbench/contrib/userDataSync/browser/media/check-light.svg`));
@@ -39,6 +41,7 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
 
 	private static readonly ENABLEMENT_SETTING = 'configurationSync.enable';
 
+	private readonly userDataSyncStore: IUserDataSyncStore | undefined;
 	private readonly syncStatusContext: IContextKey<string>;
 	private readonly authTokenContext: IContextKey<string>;
 	private readonly badgeDisposable = this._register(new MutableDisposable());
@@ -59,18 +62,26 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
 		@IDialogService private readonly dialogService: IDialogService,
 		@IStorageService private readonly storageService: IStorageService,
 		@IQuickInputService private readonly quickInputService: IQuickInputService,
-		@IProductService private readonly productService: IProductService,
+		@IInstantiationService instantiationService: IInstantiationService,
 	) {
 		super();
+		this.userDataSyncStore = getUserDataSyncStore(configurationService);
 		this.syncStatusContext = CONTEXT_SYNC_STATE.bindTo(contextKeyService);
 		this.authTokenContext = CONTEXT_AUTH_TOKEN_STATE.bindTo(contextKeyService);
 
-		this.onDidChangeAuthTokenStatus(this.authTokenService.status);
-		this.onDidChangeSyncStatus(this.userDataSyncService.status);
-		this._register(Event.debounce(authTokenService.onDidChangeStatus, () => undefined, 500)(() => this.onDidChangeAuthTokenStatus(this.authTokenService.status)));
-		this._register(Event.debounce(userDataSyncService.onDidChangeStatus, () => undefined, 500)(() => this.onDidChangeSyncStatus(this.userDataSyncService.status)));
-		this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration(UserDataSyncWorkbenchContribution.ENABLEMENT_SETTING))(() => this.onDidChangeEnablement()));
-		this.registerActions();
+		if (this.userDataSyncStore) {
+			registerConfiguration();
+			this.onDidChangeAuthTokenStatus(this.authTokenService.status);
+			this.onDidChangeSyncStatus(this.userDataSyncService.status);
+			this._register(Event.debounce(authTokenService.onDidChangeStatus, () => undefined, 500)(() => this.onDidChangeAuthTokenStatus(this.authTokenService.status)));
+			this._register(Event.debounce(userDataSyncService.onDidChangeStatus, () => undefined, 500)(() => this.onDidChangeSyncStatus(this.userDataSyncService.status)));
+			this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration(UserDataSyncWorkbenchContribution.ENABLEMENT_SETTING))(() => this.onDidChangeEnablement()));
+			this.registerActions();
+
+			if (isWeb) {
+				this._register(instantiationService.createInstance(UserDataAutoSync));
+			}
+		}
 	}
 
 	private onDidChangeAuthTokenStatus(status: AuthTokenStatus) {
@@ -112,7 +123,7 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
 		const enabled = this.configurationService.getValue<boolean>(UserDataSyncWorkbenchContribution.ENABLEMENT_SETTING);
 		if (enabled) {
 			if (this.authTokenService.status === AuthTokenStatus.SignedOut) {
-				const handle = this.notificationService.prompt(Severity.Info, localize('ask to sign in', "Please sign in with your {0} account to sync configuration across all your machines", this.productService.settingsSyncStore!.account),
+				const handle = this.notificationService.prompt(Severity.Info, localize('ask to sign in', "Please sign in with your {0} account to sync configuration across all your machines", this.userDataSyncStore!.account),
 					[
 						{
 							label: localize('Sign in', "Sign in"),
@@ -154,8 +165,8 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
 		if (this.authTokenService.status === AuthTokenStatus.SignedOut) {
 			const result = await this.dialogService.confirm({
 				type: 'info',
-				message: localize('sign in to account', "Sign in to {0}", this.productService.settingsSyncStore!.name),
-				detail: localize('ask to sign in', "Please sign in with your {0} account to sync configuration across all your machines", this.productService.settingsSyncStore!.account),
+				message: localize('sign in to account', "Sign in to {0}", this.userDataSyncStore!.name),
+				detail: localize('ask to sign in', "Please sign in with your {0} account to sync configuration across all your machines", this.userDataSyncStore!.account),
 				primaryButton: localize('Sign in', "Sign in")
 			});
 			if (!result.confirmed) {