add modified member to implement backups for scratchpads which are never dirty

Author: amunger

src/vs/workbench/contrib/searchEditor/browser/searchEditorInput.ts

@@ -131,6 +131,7 @@ export class SearchEditorInput extends EditorInput {
 			readonly onDidChangeContent = input.onDidChangeContent;
 			readonly onDidSave = input.onDidSave;
 			isDirty(): boolean { return input.isDirty(); }
+			isModified(): boolean { return input.isDirty(); }
 			backup(token: CancellationToken): Promise<IWorkingCopyBackup> { return input.backup(token); }
 			save(options?: ISaveOptions): Promise<boolean> { return input.save(0, options).then(editor => !!editor); }
 			revert(options?: IRevertOptions): Promise<void> { return input.revert(0, options); }

src/vs/workbench/services/textfile/common/textFileEditorModel.ts

@@ -674,6 +674,10 @@ export class TextFileEditorModel extends BaseTextEditorModel implements ITextFil
 		return this.dirty;
 	}
 
+	isModified(): boolean {
+		return this.dirty;
+	}
+
 	setDirty(dirty: boolean): void {
 		if (!this.isResolved()) {
 			return; // only resolved models can be marked dirty

src/vs/workbench/services/textmodelResolver/test/browser/textModelResolverService.test.ts

@@ -157,6 +157,7 @@ suite('Workbench - TextModelResolverService', () => {
 	test('resolve untitled', async () => {
 		const service = accessor.untitledTextEditorService;
 		const untitledModel = service.create();
+		untitledModel.isModified = untitledModel.isDirty;
 		const input = instantiationService.createInstance(UntitledTextEditorInput, untitledModel);
 
 		await input.resolve();

src/vs/workbench/services/untitled/common/untitledTextEditorModel.ts

@@ -67,7 +67,7 @@ export interface IUntitledTextEditorModel extends ITextEditorModel, ILanguageSup
 	resolve(): Promise<void>;
 }
 
-export class UntitledTextEditorModel extends BaseTextEditorModel implements IUntitledTextEditorModel {
+export class UntitledTextEditorModel extends BaseTextEditorModel implements IUntitledTextEditorModel, IWorkingCopy {
 
 	private static readonly FIRST_LINE_NAME_MAX_LENGTH = 40;
 	private static readonly FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH = UntitledTextEditorModel.FIRST_LINE_NAME_MAX_LENGTH * 10;
@@ -243,6 +243,10 @@ export class UntitledTextEditorModel extends BaseTextEditorModel implements IUnt
 		return this.dirty;
 	}
 
+	isModified(): boolean {
+		return this.dirty;
+	}
+
 	private setDirty(dirty: boolean): void {
 		if (this.dirty === dirty) {
 			return;

src/vs/workbench/services/workingCopy/browser/workingCopyBackupTracker.ts

@@ -32,27 +32,27 @@ export class BrowserWorkingCopyBackupTracker extends WorkingCopyBackupTracker im
 	protected onFinalBeforeShutdown(reason: ShutdownReason): boolean {
 
 		// Web: we cannot perform long running in the shutdown phase
-		// As such we need to check sync if there are any dirty working
+		// As such we need to check sync if there are any modified working
 		// copies that have not been backed up yet and then prevent the
 		// shutdown if that is the case.
 
-		const dirtyWorkingCopies = this.workingCopyService.dirtyWorkingCopies;
-		if (!dirtyWorkingCopies.length) {
-			return false; // no dirty: no veto
+		const modifiedWorkingCopies = this.workingCopyService.modifiedWorkingCopies;
+		if (!modifiedWorkingCopies.length) {
+			return false; // no unsaved changes: no veto
 		}
 
-		if (!this.filesConfigurationService.isHotExitEnabled) {
+		if (this.workingCopyService.hasDirty && !this.filesConfigurationService.isHotExitEnabled) {
 			return true; // dirty without backup: veto
 		}
 
-		for (const dirtyWorkingCopy of dirtyWorkingCopies) {
-			if (!this.workingCopyBackupService.hasBackupSync(dirtyWorkingCopy, this.getContentVersion(dirtyWorkingCopy))) {
+		for (const modifiedWorkingCopy of modifiedWorkingCopies) {
+			if (!this.workingCopyBackupService.hasBackupSync(modifiedWorkingCopy, this.getContentVersion(modifiedWorkingCopy))) {
 				this.logService.warn('Unload veto: pending backups');
 
-				return true; // dirty without backup: veto
+				return true; // unsaved content without backup: veto
 			}
 		}
 
-		return false; // dirty with backups: no veto
+		return false; // unsaved content backed up: no veto
 	}
 }

src/vs/workbench/services/workingCopy/common/resourceWorkingCopy.ts

@@ -143,6 +143,15 @@ export abstract class ResourceWorkingCopy extends Disposable implements IResourc
 
 	//#endregion
 
+	//#region Modified Tracking
+
+	// Overridden when the Working Copies need to differentiate between
+	// dirty and modified e.g. scratchpads
+	isModified(): boolean {
+		return this.isDirty();
+	}
+
+	//#endregion
 
 	//#region Abstract
 
@@ -161,4 +170,5 @@ export abstract class ResourceWorkingCopy extends Disposable implements IResourc
 	abstract revert(options?: IRevertOptions): Promise<void>;
 
 	//#endregion
+
 }

src/vs/workbench/services/workingCopy/common/untitledFileWorkingCopy.ts

@@ -37,9 +37,9 @@ export interface IUntitledFileWorkingCopyModelContentChangedEvent {
 
 	/**
 	 * Flag that indicates that the content change should
-	 * clear the dirty flag, e.g. because the contents are
+	 * clear the dirty/modified flags, e.g. because the contents are
 	 * back to being empty or back to an initial state that
-	 * should not be considered as dirty.
+	 * should not be considered as modified.
 	 */
 	readonly isInitial: boolean;
 }
@@ -137,20 +137,25 @@ export class UntitledFileWorkingCopy<M extends IUntitledFileWorkingCopyModel> ex
 
 	//#region Dirty
 
-	private dirty = !this.isScratchpad &&
-		(this.hasAssociatedFilePath || Boolean(this.initialContents && this.initialContents.markDirty !== false));
+	private modified = this.hasAssociatedFilePath || Boolean(this.initialContents && this.initialContents.markDirty !== false);
 
 	isDirty(): boolean {
-		return this.dirty;
+		return this.modified && !this.isScratchpad; // Scratchpad working copies are never dirty
 	}
 
-	private setDirty(dirty: boolean): void {
-		if (this.dirty === dirty || this.isScratchpad /* Scratchpad working copies are never dirty */) {
+	isModified(): boolean {
+		return this.modified;
+	}
+
+	private setModified(modified: boolean): void {
+		if (this.modified === modified) {
 			return;
 		}
 
-		this.dirty = dirty;
-		this._onDidChangeDirty.fire();
+		this.modified = modified;
+		if (!this.isScratchpad) {
+			this._onDidChangeDirty.fire();
+		}
 	}
 
 	//#endregion
@@ -191,8 +196,8 @@ export class UntitledFileWorkingCopy<M extends IUntitledFileWorkingCopyModel> ex
 		// Create model
 		await this.doCreateModel(untitledContents);
 
-		// Untitled associated to file path are dirty right away as well as untitled with content
-		this.setDirty(this.hasAssociatedFilePath || !!backup || Boolean(this.initialContents && this.initialContents.markDirty !== false));
+		// Untitled associated to file path are modified right away as well as untitled with content
+		this.setModified(this.hasAssociatedFilePath || !!backup || Boolean(this.initialContents && this.initialContents.markDirty !== false));
 
 		// If we have initial contents, make sure to emit this
 		// as the appropriate events to the outside.
@@ -226,12 +231,12 @@ export class UntitledFileWorkingCopy<M extends IUntitledFileWorkingCopyModel> ex
 		// in case provided by the change event and in case we do not
 		// have an associated path set
 		if (!this.hasAssociatedFilePath && e.isInitial) {
-			this.setDirty(false);
+			this.setModified(false);
 		}
 
 		// Turn dirty otherwise
 		else {
-			this.setDirty(true);
+			this.setModified(true);
 		}
 
 		// Emit as general content change event
@@ -289,8 +294,8 @@ export class UntitledFileWorkingCopy<M extends IUntitledFileWorkingCopyModel> ex
 	async revert(): Promise<void> {
 		this.trace('revert()');
 
-		// No longer dirty
-		this.setDirty(false);
+		// No longer modified
+		this.setModified(false);
 
 		// Emit as event
 		this._onDidRevert.fire();

src/vs/workbench/services/workingCopy/common/workingCopy.ts

@@ -163,8 +163,19 @@ export interface IWorkingCopy extends IWorkingCopyIdentifier {
 
 	//#region Dirty Tracking
 
+	/**
+	 * Indicates that the file has unsaved changes
+	 * and should confirm before closing.
+	 */
 	isDirty(): boolean;
 
+	/**
+	 * Indicates that the file has unsaved changes.
+	 * Used for backup tracking and accounts for
+	 * working copies that are never dirty e.g. scratchpads
+	 */
+	isModified(): boolean;
+
 	//#endregion
 
 

src/vs/workbench/services/workingCopy/common/workingCopyBackupTracker.ts

@@ -159,13 +159,16 @@ export abstract class WorkingCopyBackupTracker extends Disposable {
 			return;
 		}
 
-		// Schedule backup if dirty or a scratchpad
-		if (workingCopy.isDirty() || (workingCopy.capabilities & WorkingCopyCapabilities.Scratchpad)) {
+		// Schedule backup for unsaved content
+		if (workingCopy.isModified()) {
 			// this listener will make sure that the backup is
 			// pushed out for as long as the user is still changing
 			// the content of the working copy.
 			this.scheduleBackup(workingCopy);
 		}
+		else {
+			this.discardBackup(workingCopy);
+		}
 	}
 
 	private scheduleBackup(workingCopy: IWorkingCopy): void {
@@ -183,8 +186,8 @@ export abstract class WorkingCopyBackupTracker extends Disposable {
 				return;
 			}
 
-			// Backup if dirty
-			if (workingCopy.isDirty()) {
+			// Backup if modified
+			if (workingCopy.isModified()) {
 				this.logService.trace(`[backup tracker] creating backup`, workingCopy.resource.toString(), workingCopy.typeId);
 
 				try {
@@ -193,7 +196,7 @@ export abstract class WorkingCopyBackupTracker extends Disposable {
 						return;
 					}
 
-					if (workingCopy.isDirty()) {
+					if (workingCopy.isModified()) {
 						this.logService.trace(`[backup tracker] storing backup`, workingCopy.resource.toString(), workingCopy.typeId);
 
 						await this.workingCopyBackupService.backup(workingCopy, backup.content, this.getContentVersion(workingCopy), backup.meta, cts.token);

src/vs/workbench/services/workingCopy/common/workingCopyService.ts

@@ -68,6 +68,12 @@ export interface IWorkingCopyService {
 	 */
 	readonly dirtyWorkingCopies: readonly IWorkingCopy[];
 
+	/**
+	 * All working copies with unsaved changes,
+	 * including scratchpads, which are never dirty
+	 */
+	readonly modifiedWorkingCopies: readonly IWorkingCopy[];
+
 	/**
 	 * Whether there is any registered working copy that is dirty.
 	 */
@@ -265,6 +271,10 @@ export class WorkingCopyService extends Disposable implements IWorkingCopyServic
 		return this.workingCopies.filter(workingCopy => workingCopy.isDirty());
 	}
 
+	get modifiedWorkingCopies(): IWorkingCopy[] {
+		return this.workingCopies.filter(workingCopy => workingCopy.isModified);
+	}
+
 	isDirty(resource: URI, typeId?: string): boolean {
 		const workingCopies = this.mapResourceToWorkingCopies.get(resource);
 		if (workingCopies) {