Merge from vscode 1eb87b0e9ce9886afeaecec22b31abd0d9b7939f (#7282)

* Merge from vscode 1eb87b0e9ce9886afeaecec22b31abd0d9b7939f

* fix various icon issues

* fix preview features

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

@@ -0,0 +1,253 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IFileService, FileSystemProviderErrorCode, FileSystemProviderError, IFileContent } from 'vs/platform/files/common/files';
+import { IUserData, UserDataSyncStoreError, UserDataSyncStoreErrorCode, ISynchroniser, SyncStatus, ISettingsMergeService, IUserDataSyncStoreService } from 'vs/platform/userDataSync/common/userDataSync';
+import { VSBuffer } from 'vs/base/common/buffer';
+import { parse, ParseError } from 'vs/base/common/json';
+import { localize } from 'vs/nls';
+import { Emitter, Event } from 'vs/base/common/event';
+import { ILogService } from 'vs/platform/log/common/log';
+import { CancelablePromise, createCancelablePromise, ThrottledDelayer } from 'vs/base/common/async';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { URI } from 'vs/base/common/uri';
+import { joinPath } from 'vs/base/common/resources';
+
+interface ISyncPreviewResult {
+	readonly fileContent: IFileContent | null;
+	readonly remoteUserData: IUserData;
+	readonly hasLocalChanged: boolean;
+	readonly hasRemoteChanged: boolean;
+	readonly hasConflicts: boolean;
+}
+
+export class SettingsSynchroniser extends Disposable implements ISynchroniser {
+
+	private static EXTERNAL_USER_DATA_SETTINGS_KEY: string = 'settings';
+
+	private syncPreviewResultPromise: CancelablePromise<ISyncPreviewResult> | null = null;
+
+	private _status: SyncStatus = SyncStatus.Idle;
+	get status(): SyncStatus { return this._status; }
+	private _onDidChangStatus: Emitter<SyncStatus> = this._register(new Emitter<SyncStatus>());
+	readonly onDidChangeStatus: Event<SyncStatus> = this._onDidChangStatus.event;
+
+	private readonly throttledDelayer: ThrottledDelayer<void>;
+	private _onDidChangeLocal: Emitter<void> = this._register(new Emitter<void>());
+	readonly onDidChangeLocal: Event<void> = this._onDidChangeLocal.event;
+
+	private readonly lastSyncSettingsResource: URI;
+
+	constructor(
+		@IFileService private readonly fileService: IFileService,
+		@IEnvironmentService private readonly environmentService: IEnvironmentService,
+		@IUserDataSyncStoreService private readonly userDataSyncStoreService: IUserDataSyncStoreService,
+		@ISettingsMergeService private readonly settingsMergeService: ISettingsMergeService,
+		@ILogService private readonly logService: ILogService,
+	) {
+		super();
+		this.lastSyncSettingsResource = joinPath(this.environmentService.userRoamingDataHome, '.lastSyncSettings.json');
+		this.throttledDelayer = this._register(new ThrottledDelayer<void>(500));
+		this._register(Event.filter(this.fileService.onFileChanges, e => e.contains(this.environmentService.settingsResource))(() => this.throttledDelayer.trigger(() => this.onDidChangeSettings())));
+	}
+
+	private async onDidChangeSettings(): Promise<void> {
+		const localFileContent = await this.getLocalFileContent();
+		const lastSyncData = await this.getLastSyncUserData();
+		if (localFileContent && lastSyncData) {
+			if (localFileContent.value.toString() !== lastSyncData.content) {
+				this._onDidChangeLocal.fire();
+				return;
+			}
+		}
+		if (!localFileContent || !lastSyncData) {
+			this._onDidChangeLocal.fire();
+			return;
+		}
+	}
+
+	private setStatus(status: SyncStatus): void {
+		if (this._status !== status) {
+			this._status = status;
+			this._onDidChangStatus.fire(status);
+		}
+	}
+
+	async sync(_continue?: boolean): Promise<boolean> {
+
+		if (_continue) {
+			return this.continueSync();
+		}
+
+		if (this.status !== SyncStatus.Idle) {
+			return false;
+		}
+
+		this.setStatus(SyncStatus.Syncing);
+
+		try {
+			const result = await this.getPreview();
+			if (result.hasConflicts) {
+				this.setStatus(SyncStatus.HasConflicts);
+				return false;
+			}
+			await this.apply();
+			return true;
+		} catch (e) {
+			this.syncPreviewResultPromise = null;
+			this.setStatus(SyncStatus.Idle);
+			if (e instanceof UserDataSyncStoreError && e.code === UserDataSyncStoreErrorCode.Rejected) {
+				// Rejected as there is a new remote version. Syncing again,
+				this.logService.info('Failed to Synchronise settings as there is a new remote version available. Synchronising again...');
+				return this.sync();
+			}
+			if (e instanceof FileSystemProviderError && e.code === FileSystemProviderErrorCode.FileExists) {
+				// Rejected as there is a new local version. Syncing again.
+				this.logService.info('Failed to Synchronise settings as there is a new local version available. Synchronising again...');
+				return this.sync();
+			}
+			throw e;
+		}
+	}
+
+	private async continueSync(): Promise<boolean> {
+		if (this.status !== SyncStatus.HasConflicts) {
+			return false;
+		}
+		await this.apply();
+		return true;
+	}
+
+	private async apply(): Promise<void> {
+		if (!this.syncPreviewResultPromise) {
+			return;
+		}
+
+		if (await this.fileService.exists(this.environmentService.settingsSyncPreviewResource)) {
+			const settingsPreivew = await this.fileService.readFile(this.environmentService.settingsSyncPreviewResource);
+			const content = settingsPreivew.value.toString();
+			if (this.hasErrors(content)) {
+				return Promise.reject(localize('errorInvalidSettings', "Unable to sync settings. Please resolve conflicts without any errors/warnings and try again."));
+			}
+
+			let { fileContent, remoteUserData, hasLocalChanged, hasRemoteChanged } = await this.syncPreviewResultPromise;
+			if (hasRemoteChanged) {
+				const ref = await this.writeToRemote(content, remoteUserData.ref);
+				remoteUserData = { ref, content };
+			}
+			if (hasLocalChanged) {
+				await this.writeToLocal(content, fileContent);
+			}
+			if (remoteUserData.content) {
+				await this.updateLastSyncValue(remoteUserData);
+			}
+
+			// Delete the preview
+			await this.fileService.del(this.environmentService.settingsSyncPreviewResource);
+		}
+
+		this.syncPreviewResultPromise = null;
+		this.setStatus(SyncStatus.Idle);
+	}
+
+	private hasErrors(content: string): boolean {
+		const parseErrors: ParseError[] = [];
+		parse(content, parseErrors);
+		return parseErrors.length > 0;
+	}
+
+	private getPreview(): Promise<ISyncPreviewResult> {
+		if (!this.syncPreviewResultPromise) {
+			this.syncPreviewResultPromise = createCancelablePromise(token => this.generatePreview());
+		}
+		return this.syncPreviewResultPromise;
+	}
+
+	private async generatePreview(): Promise<ISyncPreviewResult> {
+		const lastSyncData = await this.getLastSyncUserData();
+		const remoteUserData = await this.userDataSyncStoreService.read(SettingsSynchroniser.EXTERNAL_USER_DATA_SETTINGS_KEY, lastSyncData);
+		const remoteContent: string | null = remoteUserData.content;
+		// Get file content last to get the latest
+		const fileContent = await this.getLocalFileContent();
+		let hasLocalChanged: boolean = false;
+		let hasRemoteChanged: boolean = false;
+		let hasConflicts: boolean = false;
+
+		// First time sync to remote
+		if (fileContent && !remoteContent) {
+			this.logService.trace('Settings Sync: Remote contents does not exist. So sync with settings file.');
+			hasRemoteChanged = true;
+			await this.fileService.writeFile(this.environmentService.settingsSyncPreviewResource, VSBuffer.fromString(fileContent.value.toString()));
+			return { fileContent, remoteUserData, hasLocalChanged, hasRemoteChanged, hasConflicts };
+		}
+
+		// Settings file does not exist, so sync with remote contents.
+		if (remoteContent && !fileContent) {
+			this.logService.trace('Settings Sync: Settings file does not exist. So sync with remote contents');
+			hasLocalChanged = true;
+			await this.fileService.writeFile(this.environmentService.settingsSyncPreviewResource, VSBuffer.fromString(remoteContent));
+			return { fileContent, remoteUserData, hasLocalChanged, hasRemoteChanged, hasConflicts };
+		}
+
+		if (fileContent && remoteContent) {
+			const localContent: string = fileContent.value.toString();
+			if (!lastSyncData // First time sync
+				|| lastSyncData.content !== localContent // Local has moved forwarded
+				|| lastSyncData.content !== remoteContent // Remote has moved forwarded
+			) {
+				this.logService.trace('Settings Sync: Merging remote contents with settings file.');
+				const result = await this.settingsMergeService.merge(localContent, remoteContent, lastSyncData ? lastSyncData.content : null);
+				// Sync only if there are changes
+				if (result.hasChanges) {
+					hasLocalChanged = result.mergeContent !== localContent;
+					hasRemoteChanged = result.mergeContent !== remoteContent;
+					hasConflicts = result.hasConflicts;
+					await this.fileService.writeFile(this.environmentService.settingsSyncPreviewResource, VSBuffer.fromString(result.mergeContent));
+					return { fileContent, remoteUserData, hasLocalChanged, hasRemoteChanged, hasConflicts };
+				}
+			}
+		}
+
+		this.logService.trace('Settings Sync: No changes.');
+		return { fileContent, remoteUserData, hasLocalChanged, hasRemoteChanged, hasConflicts };
+	}
+
+	private async getLastSyncUserData(): Promise<IUserData | null> {
+		try {
+			const content = await this.fileService.readFile(this.lastSyncSettingsResource);
+			return JSON.parse(content.value.toString());
+		} catch (error) {
+			return null;
+		}
+	}
+
+	private async getLocalFileContent(): Promise<IFileContent | null> {
+		try {
+			return await this.fileService.readFile(this.environmentService.settingsResource);
+		} catch (error) {
+			return null;
+		}
+	}
+
+	private async writeToRemote(content: string, ref: string | null): Promise<string> {
+		return this.userDataSyncStoreService.write(SettingsSynchroniser.EXTERNAL_USER_DATA_SETTINGS_KEY, content, ref);
+	}
+
+	private async writeToLocal(newContent: string, oldContent: IFileContent | null): Promise<void> {
+		if (oldContent) {
+			// file exists already
+			await this.fileService.writeFile(this.environmentService.settingsResource, VSBuffer.fromString(newContent), oldContent);
+		} else {
+			// file does not exist
+			await this.fileService.createFile(this.environmentService.settingsResource, VSBuffer.fromString(newContent), { overwrite: false });
+		}
+	}
+
+	private async updateLastSyncValue(remoteUserData: IUserData): Promise<void> {
+		await this.fileService.writeFile(this.lastSyncSettingsResource, VSBuffer.fromString(JSON.stringify(remoteUserData)));
+	}
+
+}

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

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
+import { Event } from 'vs/base/common/event';
+import { ISettingsMergeService } from 'vs/platform/userDataSync/common/userDataSync';
+
+export class SettingsMergeChannel implements IServerChannel {
+
+	constructor(private readonly service: ISettingsMergeService) { }
+
+	listen(_: unknown, event: string): Event<any> {
+		throw new Error(`Event not found: ${event}`);
+	}
+
+	call(context: any, command: string, args?: any): Promise<any> {
+		switch (command) {
+			case 'merge': return this.service.merge(args[0], args[1], args[2]);
+		}
+		throw new Error('Invalid call');
+	}
+}
+
+export class SettingsMergeChannelClient implements ISettingsMergeService {
+
+	_serviceBrand: undefined;
+
+	constructor(private readonly channel: IChannel) {
+	}
+
+	merge(localContent: string, remoteContent: string, baseContent: string | null): Promise<{ mergeContent: string, hasChanges: boolean, hasConflicts: boolean }> {
+		return this.channel.call('merge', [localContent, remoteContent, baseContent]);
+	}
+
+}

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

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { Event } from 'vs/base/common/event';
+
+export interface IUserData {
+	ref: string;
+	content: string | null;
+}
+
+export enum UserDataSyncStoreErrorCode {
+	Rejected = 'Rejected',
+	Unknown = 'Unknown'
+}
+
+export class UserDataSyncStoreError extends Error {
+
+	constructor(message: string, public readonly code: UserDataSyncStoreErrorCode) {
+		super(message);
+	}
+
+}
+
+export const IUserDataSyncStoreService = createDecorator<IUserDataSyncStoreService>('IUserDataSyncStoreService');
+
+export interface IUserDataSyncStoreService {
+	_serviceBrand: undefined;
+
+	readonly enabled: boolean;
+
+	readonly loggedIn: boolean;
+	readonly onDidChangeLoggedIn: Event<boolean>;
+	login(): Promise<void>;
+	logout(): Promise<void>;
+
+	read(key: string, oldValue: IUserData | null): Promise<IUserData>;
+	write(key: string, content: string, ref: string | null): Promise<string>;
+}
+
+export enum SyncSource {
+	Settings = 1,
+	Extensions
+}
+
+export enum SyncStatus {
+	Uninitialized = 'uninitialized',
+	Idle = 'idle',
+	Syncing = 'syncing',
+	HasConflicts = 'hasConflicts',
+}
+
+export interface ISynchroniser {
+
+	readonly status: SyncStatus;
+	readonly onDidChangeStatus: Event<SyncStatus>;
+	readonly onDidChangeLocal: Event<void>;
+
+	sync(_continue?: boolean): Promise<boolean>;
+}
+
+export const IUserDataSyncService = createDecorator<IUserDataSyncService>('IUserDataSyncService');
+
+export interface IUserDataSyncService extends ISynchroniser {
+	_serviceBrand: any;
+	readonly conflictsSource: SyncSource | null;
+}
+
+export const ISettingsMergeService = createDecorator<ISettingsMergeService>('ISettingsMergeService');
+
+export interface ISettingsMergeService {
+
+	_serviceBrand: undefined;
+
+	merge(localContent: string, remoteContent: string, baseContent: string | null): Promise<{ mergeContent: string, hasChanges: boolean, hasConflicts: boolean }>;
+
+}

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

@@ -0,0 +1,29 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IServerChannel } from 'vs/base/parts/ipc/common/ipc';
+import { Event } from 'vs/base/common/event';
+import { IUserDataSyncService } from 'vs/platform/userDataSync/common/userDataSync';
+
+export class UserDataSyncChannel implements IServerChannel {
+
+	constructor(private readonly service: IUserDataSyncService) { }
+
+	listen(_: unknown, event: string): Event<any> {
+		switch (event) {
+			case 'onDidChangeStatus': return this.service.onDidChangeStatus;
+			case 'onDidChangeLocal': return this.service.onDidChangeLocal;
+		}
+		throw new Error(`Event not found: ${event}`);
+	}
+
+	call(context: any, command: string, args?: any): Promise<any> {
+		switch (command) {
+			case 'sync': return this.service.sync(args[0]);
+			case 'getConflictsSource': return Promise.resolve(this.service.conflictsSource);
+		}
+		throw new Error('Invalid call');
+	}
+}

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

@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IUserDataSyncService, SyncStatus, ISynchroniser, IUserDataSyncStoreService, SyncSource } from 'vs/platform/userDataSync/common/userDataSync';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { SettingsSynchroniser } from 'vs/platform/userDataSync/common/settingsSync';
+import { Emitter, Event } from 'vs/base/common/event';
+import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { timeout } from 'vs/base/common/async';
+
+export class UserDataSyncService extends Disposable implements IUserDataSyncService {
+
+	_serviceBrand: any;
+
+	private readonly synchronisers: ISynchroniser[];
+
+	private _status: SyncStatus = SyncStatus.Uninitialized;
+	get status(): SyncStatus { return this._status; }
+	private _onDidChangeStatus: Emitter<SyncStatus> = this._register(new Emitter<SyncStatus>());
+	readonly onDidChangeStatus: Event<SyncStatus> = this._onDidChangeStatus.event;
+
+	readonly onDidChangeLocal: Event<void>;
+
+	private _conflictsSource: SyncSource | null = null;
+	get conflictsSource(): SyncSource | null { return this._conflictsSource; }
+
+	constructor(
+		@IUserDataSyncStoreService private readonly userDataSyncStoreService: IUserDataSyncStoreService,
+		@IInstantiationService private readonly instantiationService: IInstantiationService,
+	) {
+		super();
+		this.synchronisers = [
+			this.instantiationService.createInstance(SettingsSynchroniser)
+		];
+		this.updateStatus();
+		this._register(Event.any(...this.synchronisers.map(s => Event.map(s.onDidChangeStatus, () => undefined)))(() => this.updateStatus()));
+		this.onDidChangeLocal = Event.any(...this.synchronisers.map(s => s.onDidChangeLocal));
+	}
+
+	async sync(_continue?: boolean): Promise<boolean> {
+		if (!this.userDataSyncStoreService.enabled) {
+			throw new Error('Not enabled');
+		}
+		for (const synchroniser of this.synchronisers) {
+			if (!await synchroniser.sync(_continue)) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private updateStatus(): void {
+		this._conflictsSource = this.computeConflictsSource();
+		this.setStatus(this.computeStatus());
+	}
+
+	private setStatus(status: SyncStatus): void {
+		if (this._status !== status) {
+			this._status = status;
+			this._onDidChangeStatus.fire(status);
+		}
+	}
+
+	private computeStatus(): SyncStatus {
+		if (!this.userDataSyncStoreService.enabled) {
+			return SyncStatus.Uninitialized;
+		}
+		if (this.synchronisers.some(s => s.status === SyncStatus.HasConflicts)) {
+			return SyncStatus.HasConflicts;
+		}
+		if (this.synchronisers.some(s => s.status === SyncStatus.Syncing)) {
+			return SyncStatus.Syncing;
+		}
+		return SyncStatus.Idle;
+	}
+
+	private computeConflictsSource(): SyncSource | null {
+		const source = this.synchronisers.filter(s => s.status === SyncStatus.HasConflicts)[0];
+		if (source) {
+			if (source instanceof SettingsSynchroniser) {
+				return SyncSource.Settings;
+			}
+		}
+		return null;
+	}
+
+}
+
+export class UserDataAutoSync extends Disposable {
+
+	constructor(
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@IUserDataSyncService private readonly userDataSyncService: IUserDataSyncService,
+		@IUserDataSyncStoreService userDataSyncStoreService: IUserDataSyncStoreService,
+	) {
+		super();
+		if (userDataSyncStoreService.enabled) {
+			this.sync(true);
+			this._register(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('userConfiguration.enableSync'))(() => this.sync(true)));
+
+			// Sync immediately if there is a local change.
+			this._register(Event.debounce(this.userDataSyncService.onDidChangeLocal, () => undefined, 500)(() => this.sync(false)));
+		}
+	}
+
+	private async sync(loop: boolean): Promise<void> {
+		if (this.isSyncEnabled()) {
+			try {
+				await this.userDataSyncService.sync();
+			} catch (e) {
+				// Ignore errors
+			}
+			if (loop) {
+				await timeout(1000 * 5); // Loop sync for every 5s.
+				this.sync(loop);
+			}
+		}
+	}
+
+	private isSyncEnabled(): boolean {
+		const { user: userLocal } = this.configurationService.inspect<boolean>('userConfiguration.enableSync');
+		return userLocal === undefined || userLocal;
+	}
+
+}

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

@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+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 { Emitter, Event } from 'vs/base/common/event';
+import { IRequestService, asText } 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 } from 'vs/base/parts/request/common/request';
+
+export class UserDataSyncStoreService extends Disposable implements IUserDataSyncStoreService {
+
+	_serviceBrand: any;
+
+	get enabled(): boolean { return !!this.productService.settingsSyncStoreUrl; }
+
+	private _loggedIn: boolean = false;
+	get loggedIn(): boolean { return this._loggedIn; }
+	private readonly _onDidChangeLoggedIn: Emitter<boolean> = this._register(new Emitter<boolean>());
+	readonly onDidChangeLoggedIn: Event<boolean> = this._onDidChangeLoggedIn.event;
+
+	constructor(
+		@IProductService private readonly productService: IProductService,
+		@IRequestService private readonly requestService: IRequestService,
+	) {
+		super();
+	}
+
+	async login(): Promise<void> {
+	}
+
+	async logout(): Promise<void> {
+	}
+
+	async read(key: string, oldValue: IUserData | null): Promise<IUserData> {
+		if (!this.enabled) {
+			return Promise.reject(new Error('No settings sync store url configured.'));
+		}
+
+		const url = joinPath(URI.parse(this.productService.settingsSyncStoreUrl!), key).toString();
+		const headers: IHeaders = {};
+		if (oldValue) {
+			headers['If-None-Match'] = oldValue.ref;
+		}
+
+		const context = await this.requestService.request({ type: 'GET', url, headers }, CancellationToken.None);
+
+		if (context.res.statusCode === 304) {
+			// There is no new value. Hence return the old value.
+			return oldValue!;
+		}
+
+		const ref = context.res.headers['etag'];
+		if (!ref) {
+			throw new Error('Server did not return the ref');
+		}
+		const content = await asText(context);
+		return { ref, content };
+	}
+
+	async write(key: string, data: string, ref: string | null): Promise<string> {
+		if (!this.enabled) {
+			return Promise.reject(new Error('No settings sync store url configured.'));
+		}
+
+		const url = joinPath(URI.parse(this.productService.settingsSyncStoreUrl!), key).toString();
+		const headers: IHeaders = { 'Content-Type': 'text/plain' };
+		if (ref) {
+			headers['If-Match'] = ref;
+		}
+
+		const context = await this.requestService.request({ type: 'POST', url, data, headers }, CancellationToken.None);
+
+		if (context.res.statusCode === 412) {
+			// There is a new value. Throw Rejected Error
+			throw new UserDataSyncStoreError('New data exists', UserDataSyncStoreErrorCode.Rejected);
+		}
+
+		const newRef = context.res.headers['etag'];
+		if (!newRef) {
+			throw new Error('Server did not return the ref');
+		}
+		return newRef;
+	}
+
+}