Merge remote-tracking branch 'origin/master' into tyriar/101_hot_exit

src/vs/workbench/api/node/mainThreadEditorsTracker.ts

@@ -102,13 +102,13 @@ export class MainThreadTextEditor {
 		this._onConfigurationChanged = new Emitter<IResolvedTextEditorConfiguration>();
 
 		this._lastSelection = [ new Selection(1,1,1,1) ];
-		this._setConfiguration(this._readConfiguration(this._model, this._codeEditor));
 		this._modelListeners = [];
 		this._modelListeners.push(this._model.onDidChangeOptions((e) => {
 			this._setConfiguration(this._readConfiguration(this._model, this._codeEditor));
 		}));
 
 		this.setCodeEditor(codeEditor);
+		this._setConfiguration(this._readConfiguration(this._model, this._codeEditor));
 	}
 
 	public dispose(): void {

src/vs/workbench/browser/actions/openSettings.ts

@@ -57,9 +57,9 @@ export class BaseTwoEditorsAction extends Action {
 	}
 
 	protected createIfNotExists(resource: URI, contents: string): TPromise<boolean> {
-		return this.fileService.resolveContent(resource, { acceptTextOnly: true }).then(null, (error) => {
+		return this.fileService.resolveContent(resource, { acceptTextOnly: true }).then(null, error => {
 			if ((<IFileOperationResult>error).fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
-				return this.fileService.updateContent(resource, contents).then(null, (error) => {
+				return this.fileService.updateContent(resource, contents).then(null, error => {
 					return TPromise.wrapError(new Error(nls.localize('fail.createSettings', "Unable to create '{0}' ({1}).", labels.getPathLabel(resource, this.contextService), error)));
 				});
 			}
@@ -72,7 +72,7 @@ export class BaseTwoEditorsAction extends Action {
 
 		// Create as needed and open in editor
 		return this.createIfNotExists(editableResource, defaultEditableContents).then(() => {
-			return this.editorService.createInput({ resource: editableResource }).then((typedRightHandEditableInput) => {
+			return this.editorService.createInput({ resource: editableResource }).then(typedRightHandEditableInput => {
 				const editors = [
 					{ input: leftHandDefaultInput, position: Position.LEFT, options: { pinned: true } },
 					{ input: typedRightHandEditableInput, position: Position.CENTER, options: { pinned: true } }
@@ -150,9 +150,9 @@ export class OpenGlobalSettingsAction extends BaseOpenSettingsAction {
 				message: nls.localize('workspaceHasSettings', "The currently opened folder contains workspace settings that may override user settings"),
 				actions: [
 					new Action('open.workspaceSettings', nls.localize('openWorkspaceSettings', "Open Workspace Settings"), null, true, () => {
-						let editorCount = this.editorService.getVisibleEditors().length;
+						const editorCount = this.editorService.getVisibleEditors().length;
 
-						return this.editorService.createInput({ resource: this.contextService.toResource(WORKSPACE_CONFIG_DEFAULT_PATH) }).then((typedInput) => {
+						return this.editorService.createInput({ resource: this.contextService.toResource(WORKSPACE_CONFIG_DEFAULT_PATH) }).then(typedInput => {
 							return this.editorService.openEditor(typedInput, { pinned: true }, editorCount === 2 ? Position.RIGHT : editorCount === 1 ? Position.CENTER : void 0);
 						});
 					}),
@@ -167,7 +167,7 @@ export class OpenGlobalSettingsAction extends BaseOpenSettingsAction {
 		}
 
 		// Open settings
-		let emptySettingsHeader = nls.localize('emptySettingsHeader', "Place your settings in this file to overwrite the default settings");
+		const emptySettingsHeader = nls.localize('emptySettingsHeader', "Place your settings in this file to overwrite the default settings");
 
 		return this.open('// ' + emptySettingsHeader + '\n{\n}', URI.file(this.environmentService.appSettingsPath));
 	}
@@ -195,7 +195,7 @@ export class OpenGlobalKeybindingsAction extends BaseTwoEditorsAction {
 	}
 
 	public run(event?: any): TPromise<void> {
-		let emptyContents = '// ' + nls.localize('emptyKeybindingsHeader', "Place your key bindings in this file to overwrite the defaults") + '\n[\n]';
+		const emptyContents = '// ' + nls.localize('emptyKeybindingsHeader', "Place your key bindings in this file to overwrite the defaults") + '\n[\n]';
 
 		return this.openTwoEditors(DefaultKeybindingsInput.getInstance(this.instantiationService, this.keybindingService), URI.file(this.environmentService.appKeybindingsPath), emptyContents);
 	}
@@ -213,7 +213,7 @@ export class OpenWorkspaceSettingsAction extends BaseOpenSettingsAction {
 			return;
 		}
 
-		let emptySettingsHeader = [
+		const emptySettingsHeader = [
 			'// ' + nls.localize('emptySettingsHeader1', "Place your settings in this file to overwrite default and user settings."),
 			'{',
 			'}'
@@ -228,8 +228,8 @@ class DefaultSettingsInput extends StringEditorInput {
 
 	public static getInstance(instantiationService: IInstantiationService, configurationService: IWorkspaceConfigurationService): DefaultSettingsInput {
 		if (!DefaultSettingsInput.INSTANCE) {
-			let editorConfig = configurationService.getConfiguration<any>();
-			let defaults = getDefaultValuesContent(editorConfig.editor.insertSpaces ? strings.repeat(' ', editorConfig.editor.tabSize) : '\t');
+			const editorConfig = configurationService.getConfiguration<any>();
+			const defaults = getDefaultValuesContent(editorConfig.editor.insertSpaces ? strings.repeat(' ', editorConfig.editor.tabSize) : '\t');
 
 			let defaultsHeader = '// ' + nls.localize('defaultSettingsHeader', "Overwrite settings by placing them into your settings file.");
 			defaultsHeader += '\n// ' + nls.localize('defaultSettingsHeader2', "See http://go.microsoft.com/fwlink/?LinkId=808995 for the most commonly used settings.");
@@ -249,8 +249,8 @@ class DefaultKeybindingsInput extends StringEditorInput {
 
 	public static getInstance(instantiationService: IInstantiationService, keybindingService: IKeybindingService): DefaultKeybindingsInput {
 		if (!DefaultKeybindingsInput.INSTANCE) {
-			let defaultsHeader = '// ' + nls.localize('defaultKeybindingsHeader', "Overwrite key bindings by placing them into your key bindings file.");
-			let defaultContents = keybindingService.getDefaultKeybindings();
+			const defaultsHeader = '// ' + nls.localize('defaultKeybindingsHeader', "Overwrite key bindings by placing them into your key bindings file.");
+			const defaultContents = keybindingService.getDefaultKeybindings();
 
 			DefaultKeybindingsInput.INSTANCE = instantiationService.createInstance(DefaultKeybindingsInput, nls.localize('defaultKeybindings', "Default Keyboard Shortcuts"), null, defaultsHeader + '\n' + defaultContents, 'application/json', false);
 		}

src/vs/workbench/browser/parts/editor/editorActions.ts

@@ -190,10 +190,14 @@ export class FocusFirstGroupAction extends Action {
 		const history = this.historyService.getHistory();
 		for (let input of history) {
 
-			// For now only support to open resources from history to the side
+			// For now only support to open files from history to the side
+			if (input instanceof EditorInput) {
 				if (!!getUntitledOrFileResource(input)) {
 					return this.editorService.openEditor(input, null, Position.LEFT);
 				}
+			} else {
+				return this.editorService.openEditor(input as IResourceInput, Position.LEFT);
+			}
 		}
 
 		return TPromise.as(true);
@@ -259,9 +263,13 @@ export abstract class BaseFocusSideGroupAction extends Action {
 			for (let input of history) {
 
 				// For now only support to open files from history to the side
+				if (input instanceof EditorInput) {
 					if (!!getUntitledOrFileResource(input)) {
 						return this.editorService.openEditor(input, { pinned: true }, this.getTargetEditorSide());
 					}
+				} else {
+					return this.editorService.openEditor({ resource: (input as IResourceInput).resource, options: { pinned: true } }, this.getTargetEditorSide());
+				}
 			}
 		}
 

src/vs/workbench/browser/parts/quickopen/quickOpenController.ts

@@ -24,7 +24,9 @@ import {QuickOpenWidget, HideReason} from 'vs/base/parts/quickopen/browser/quick
 import {ContributableActionProvider} from 'vs/workbench/browser/actionBarRegistry';
 import labels = require('vs/base/common/labels');
 import paths = require('vs/base/common/paths');
+import {ITextFileService} from 'vs/workbench/services/textfile/common/textfiles';
 import {Registry} from 'vs/platform/platform';
+import {IResourceInput, IEditorInput} from 'vs/platform/editor/common/editor';
 import {IModeService} from 'vs/editor/common/services/modeService';
 import {getIconClasses} from 'vs/workbench/browser/labels';
 import {IModelService} from 'vs/editor/common/services/modelService';
@@ -744,14 +746,28 @@ export class QuickOpenController extends WorkbenchComponent implements IQuickOpe
 
 		const results: QuickOpenEntry[] = [];
 		history.forEach(input => {
-			const resource = getUntitledOrFileResource(input);
+			let resource: URI;
+			if (input instanceof EditorInput) {
+				resource = getUntitledOrFileResource(input);
+			} else {
+				resource = (input as IResourceInput).resource;
+			}
+
 			if (!resource) {
 				return; //For now, only support to match on inputs that provide resource information
 			}
 
+			let searchTargetToMatch: string;
+			if (searchInPath) {
+				searchTargetToMatch = labels.getPathLabel(resource, this.contextService);
+			} else if (input instanceof EditorInput) {
+				searchTargetToMatch = input.getName();
+			} else {
+				searchTargetToMatch = paths.basename((input as IResourceInput).resource.fsPath);
+			}
+
 			// Check if this entry is a match for the search value
-			const targetToMatch = searchInPath ? labels.getPathLabel(resource, this.contextService) : input.getName();
-			if (!filters.matchesFuzzy(searchValue, targetToMatch)) {
+			if (!filters.matchesFuzzy(searchValue, searchTargetToMatch)) {
 				return;
 			}
 
@@ -1018,28 +1034,42 @@ export class EditorHistoryEntryGroup extends QuickOpenEntryGroup {
 }
 
 export class EditorHistoryEntry extends EditorQuickOpenEntry {
-	private input: EditorInput;
+	private input: IEditorInput | IResourceInput;
 	private resource: URI;
+	private label: string;
+	private description: string;
 
 	constructor(
-		input: EditorInput,
+		input: IEditorInput | IResourceInput,
 		@IWorkbenchEditorService editorService: IWorkbenchEditorService,
 		@IModeService private modeService: IModeService,
 		@IModelService private modelService: IModelService,
+		@ITextFileService private textFileService: ITextFileService,
+		@IWorkspaceContextService contextService: IWorkspaceContextService,
 		@IConfigurationService private configurationService: IConfigurationService
 	) {
 		super(editorService);
 
 		this.input = input;
+
+		if (input instanceof EditorInput) {
 			this.resource = getUntitledOrFileResource(input);
+			this.label = input.getName();
+			this.description = input.getDescription();
+		} else {
+			const resourceInput = input as IResourceInput;
+			this.resource = resourceInput.resource;
+			this.label = paths.basename(resourceInput.resource.fsPath);
+			this.description = labels.getPathLabel(paths.dirname(this.resource.fsPath), contextService);
+		}
 	}
 
 	public getIcon(): string {
-		return this.input.isDirty() ? 'dirty' : '';
+		return this.resource && this.textFileService.isDirty(this.resource) ? 'dirty' : '';
 	}
 
 	public getLabel(): string {
-		return this.input.getName();
+		return this.label;
 	}
 
 	public getLabelOptions(): IIconLabelOptions {
@@ -1053,27 +1083,27 @@ export class EditorHistoryEntry extends EditorQuickOpenEntry {
 	}
 
 	public getDescription(): string {
-		return this.input.getDescription();
+		return this.description;
 	}
 
 	public getResource(): URI {
 		return this.resource;
 	}
 
-	public getInput(): EditorInput {
+	public getInput(): IEditorInput | IResourceInput {
 		return this.input;
 	}
 
-	public matches(input: EditorInput): boolean {
-		return this.input.matches(input);
-	}
-
 	public run(mode: Mode, context: IEntryRunContext): boolean {
 		if (mode === Mode.OPEN) {
 			const sideBySide = !context.quickNavigateConfiguration && context.keymods.indexOf(KeyMod.CtrlCmd) >= 0;
 			const pinned = !this.configurationService.getConfiguration<IWorkbenchEditorConfiguration>().workbench.editor.enablePreviewFromQuickOpen;
 
+			if (this.input instanceof EditorInput) {
 				this.editorService.openEditor(this.input, { pinned }, sideBySide).done(null, errors.onUnexpectedError);
+			} else {
+				this.editorService.openEditor({ resource: (this.input as IResourceInput).resource, options: { pinned: true } }, sideBySide);
+			}
 
 			return true;
 		}

src/vs/workbench/electron-browser/actions.ts

@@ -18,12 +18,12 @@ import product from 'vs/platform/product';
 import pkg from 'vs/platform/package';
 import errors = require('vs/base/common/errors');
 import {IMessageService, Severity} from 'vs/platform/message/common/message';
-import {IWindowConfiguration} from 'vs/workbench/electron-browser/common';
 import {IWorkspaceContextService} from 'vs/platform/workspace/common/workspace';
 import {IPartService} from 'vs/workbench/services/part/common/partService';
 import {IEnvironmentService} from 'vs/platform/environment/common/environment';
+import {IConfigurationEditingService, ConfigurationTarget} from 'vs/workbench/services/configuration/common/configurationEditing';
 import {IExtensionManagementService, LocalExtensionType, ILocalExtension} from 'vs/platform/extensionManagement/common/extensionManagement';
-import {IConfigurationService} from 'vs/platform/configuration/common/configuration';
+import {IWorkspaceConfigurationService} from 'vs/workbench/services/configuration/common/configuration';
 import {CommandsRegistry} from 'vs/platform/commands/common/commands';
 import paths = require('vs/base/common/paths');
 import {isMacintosh} from 'vs/base/common/platform';
@@ -205,44 +205,79 @@ export class ToggleDevToolsAction extends Action {
 	}
 }
 
-export class ZoomInAction extends Action {
+export abstract class BaseZoomAction extends Action {
+	private static SETTING_KEY = 'window.zoomLevel';
+
+	constructor(
+		id: string,
+		label: string,
+		@IMessageService private messageService: IMessageService,
+		@IWorkspaceConfigurationService private configurationService: IWorkspaceConfigurationService,
+		@IConfigurationEditingService private configurationEditingService: IConfigurationEditingService
+	) {
+		super(id, label);
+	}
+
+	protected setConfiguredZoomLevel(level: number): void {
+		let target = ConfigurationTarget.USER;
+		if (typeof this.configurationService.lookup(BaseZoomAction.SETTING_KEY).workspace === 'number') {
+			target = ConfigurationTarget.WORKSPACE;
+		}
+
+		const applyZoom = () => {
+			webFrame.setZoomLevel(level);
+			browser.setZoomLevel(level); // Ensure others can listen to zoom level changes
+		};
+
+		this.configurationEditingService.writeConfiguration(target, { key: BaseZoomAction.SETTING_KEY, value: level }).done(() => applyZoom(), error => applyZoom());
+	}
+}
+
+export class ZoomInAction extends BaseZoomAction {
 
 	public static ID = 'workbench.action.zoomIn';
 	public static LABEL = nls.localize('zoomIn', "Zoom In");
 
-	constructor(id: string, label: string) {
-		super(id, label);
+	constructor(
+		id: string,
+		label: string,
+		@IMessageService messageService: IMessageService,
+		@IWorkspaceConfigurationService configurationService: IWorkspaceConfigurationService,
+		@IConfigurationEditingService configurationEditingService: IConfigurationEditingService
+	) {
+		super(id, label, messageService, configurationService, configurationEditingService);
 	}
 
 	public run(): TPromise<boolean> {
-		webFrame.setZoomLevel(webFrame.getZoomLevel() + 1);
-		browser.setZoomLevel(webFrame.getZoomLevel()); // Ensure others can listen to zoom level changes
+		this.setConfiguredZoomLevel(webFrame.getZoomLevel() + 1);
 
 		return TPromise.as(true);
 	}
 }
 
-export class ZoomOutAction extends Action {
+export class ZoomOutAction extends BaseZoomAction {
 
 	public static ID = 'workbench.action.zoomOut';
 	public static LABEL = nls.localize('zoomOut', "Zoom Out");
 
 	constructor(
 		id: string,
-		label: string
+		label: string,
+		@IMessageService messageService: IMessageService,
+		@IWorkspaceConfigurationService configurationService: IWorkspaceConfigurationService,
+		@IConfigurationEditingService configurationEditingService: IConfigurationEditingService
 	) {
-		super(id, label);
+		super(id, label, messageService, configurationService, configurationEditingService);
 	}
 
 	public run(): TPromise<boolean> {
-		webFrame.setZoomLevel(webFrame.getZoomLevel() - 1);
-		browser.setZoomLevel(webFrame.getZoomLevel()); // Ensure others can listen to zoom level changes
+		this.setConfiguredZoomLevel(webFrame.getZoomLevel() - 1);
 
 		return TPromise.as(true);
 	}
 }
 
-export class ZoomResetAction extends Action {
+export class ZoomResetAction extends BaseZoomAction {
 
 	public static ID = 'workbench.action.zoomReset';
 	public static LABEL = nls.localize('zoomReset', "Reset Zoom");
@@ -250,27 +285,18 @@ export class ZoomResetAction extends Action {
 	constructor(
 		id: string,
 		label: string,
-		@IConfigurationService private configurationService: IConfigurationService
+		@IMessageService messageService: IMessageService,
+		@IWorkspaceConfigurationService configurationService: IWorkspaceConfigurationService,
+		@IConfigurationEditingService configurationEditingService: IConfigurationEditingService
 	) {
-		super(id, label);
+		super(id, label, messageService, configurationService, configurationEditingService);
 	}
 
 	public run(): TPromise<boolean> {
-		const level = this.getConfiguredZoomLevel();
-		webFrame.setZoomLevel(level);
-		browser.setZoomLevel(webFrame.getZoomLevel()); // Ensure others can listen to zoom level changes
+		this.setConfiguredZoomLevel(0);
 
 		return TPromise.as(true);
 	}
-
-	private getConfiguredZoomLevel(): number {
-		const windowConfig = this.configurationService.getConfiguration<IWindowConfiguration>();
-		if (windowConfig.window && typeof windowConfig.window.zoomLevel === 'number') {
-			return windowConfig.window.zoomLevel;
-		}
-
-		return 0; // default
-	}
 }
 
 /* Copied from loader.ts */

src/vs/workbench/parts/files/browser/fileActions.contribution.ts

@@ -163,7 +163,7 @@ const category = nls.localize('filesCategory', "Files");
 
 const registry = Registry.as<IWorkbenchActionRegistry>(ActionExtensions.WorkbenchActions);
 registry.registerWorkbenchAction(new SyncActionDescriptor(SaveFileAction, SaveFileAction.ID, SaveFileAction.LABEL, { primary: KeyMod.CtrlCmd | KeyCode.KEY_S }), 'Files: Save', category);
-registry.registerWorkbenchAction(new SyncActionDescriptor(SaveAllAction, SaveAllAction.ID, SaveAllAction.LABEL), 'Files: Save All', category);
+registry.registerWorkbenchAction(new SyncActionDescriptor(SaveAllAction, SaveAllAction.ID, SaveAllAction.LABEL, { primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KEY_S }), 'Files: Save All', category);
 registry.registerWorkbenchAction(new SyncActionDescriptor(SaveFilesAction, SaveFilesAction.ID, null /* only for programmatic trigger */), null);
 registry.registerWorkbenchAction(new SyncActionDescriptor(RevertFileAction, RevertFileAction.ID, RevertFileAction.LABEL), 'Files: Revert File', category);
 registry.registerWorkbenchAction(new SyncActionDescriptor(GlobalNewFileAction, GlobalNewFileAction.ID, GlobalNewFileAction.LABEL), 'Files: New File', category);

src/vs/workbench/services/history/browser/history.ts

@@ -70,11 +70,15 @@ export class EditorState {
 	}
 }
 
-interface ISerializedEditorInput {
+interface ILegacySerializedEditorInput {
 	id: string;
 	value: string;
 }
 
+interface ISerializedFileEditorInput {
+	resource: string;
+}
+
 export abstract class BaseHistoryService {
 	protected toUnbind: IDisposable[];
 
@@ -246,7 +250,7 @@ export class HistoryService extends BaseHistoryService implements IHistoryServic
 	private blockStackChanges: boolean;
 	private currentFileEditorState: EditorState;
 
-	private history: IEditorInput[];
+	private history: (IEditorInput|IResourceInput)[];
 	private recentlyClosedFiles: IRecentlyClosedFile[];
 	private loaded: boolean;
 	private registry: IEditorRegistry;
@@ -351,8 +355,7 @@ export class HistoryService extends BaseHistoryService implements IHistoryServic
 		if (entry.input instanceof EditorInput) {
 			openEditorPromise = this.editorService.openEditor(entry.input, options);
 		} else {
-			const resourceInput = entry.input as IResourceInput;
-			openEditorPromise = this.editorService.openEditor({ resource: resourceInput.resource, options });
+			openEditorPromise = this.editorService.openEditor({ resource: (entry.input as IResourceInput).resource, options });
 		}
 
 		openEditorPromise.done(() => {
@@ -382,38 +385,25 @@ export class HistoryService extends BaseHistoryService implements IHistoryServic
 
 		this.ensureLoaded();
 
+		const historyInput = this.preferResourceInput(input);
+
 		// Remove any existing entry and add to the beginning
 		this.removeFromHistory(input);
-		this.history.unshift(input);
+		this.history.unshift(historyInput);
 
 		// Respect max entries setting
 		if (this.history.length > HistoryService.MAX_HISTORY_ITEMS) {
 			this.history.pop();
 		}
 
-		// Restore on dispose
-		const onceDispose = once(input.onDispose);
+		// Remove this from the history unless the history input is a resource
+		// that can easily be restored even when the input gets disposed
+		if (historyInput instanceof EditorInput) {
+			const onceDispose = once(historyInput.onDispose);
 			onceDispose(() => {
-			this.restoreInHistory(input);
+				this.removeFromHistory(input);
 			});
 		}
-
-	private restoreInHistory(input: IEditorInput): void {
-		const index = this.indexOf(input);
-		if (index < 0) {
-			return;
-		}
-
-		// Using the factory we try to recreate the input
-		const restoredInput = this.restoreInput(input);
-		if (restoredInput) {
-			this.history[index] = restoredInput;
-		}
-
-		// Factory failed, just remove entry then
-		else {
-			this.removeFromHistory(input, index);
-		}
 	}
 
 	public remove(input: IEditorInput): void {
@@ -437,7 +427,7 @@ export class HistoryService extends BaseHistoryService implements IHistoryServic
 	private indexOf(input: IEditorInput): number {
 		for (let i = 0; i < this.history.length; i++) {
 			const entry = this.history[i];
-			if (entry.matches(input)) {
+			if (this.matches(input, entry)) {
 				return i;
 			}
 		}
@@ -577,20 +567,6 @@ export class HistoryService extends BaseHistoryService implements IHistoryServic
 		return s1.startLineNumber === s2.startLineNumber; // we consider the history entry same if we are on the same line
 	}
 
-	private restoreInput(input: IEditorInput): EditorInput {
-		if (input instanceof EditorInput) {
-			const factory = this.registry.getEditorInputFactory(input.getTypeId());
-			if (factory) {
-				const inputRaw = factory.serialize(input);
-				if (inputRaw) {
-					return factory.deserialize(this.instantiationService, inputRaw);
-				}
-			}
-		}
-
-		return null;
-	}
-
 	private removeFromStack(input: IEditorInput): void {
 		this.stack.forEach((e, i) => {
 			if (this.matches(input, e.input)) {
@@ -627,9 +603,7 @@ export class HistoryService extends BaseHistoryService implements IHistoryServic
 			return input.matches(typedInput);
 		}
 
-		const resourceInput = input as IResourceInput;
-
-		return this.matchesFile(resourceInput.resource, typedInput);
+		return this.matchesFile((input as IResourceInput).resource, typedInput);
 	}
 
 	private matchesFile(resource: URI, input: IEditorInput): boolean {
@@ -638,7 +612,7 @@ export class HistoryService extends BaseHistoryService implements IHistoryServic
 		return fileInput && fileInput.getResource().toString() === resource.toString();
 	}
 
-	public getHistory(): IEditorInput[] {
+	public getHistory(): (IEditorInput|IResourceInput)[] {
 		this.ensureLoaded();
 
 		return this.history.slice(0);
@@ -657,35 +631,45 @@ export class HistoryService extends BaseHistoryService implements IHistoryServic
 			return; // nothing to save because history was not used
 		}
 
-		const entries: ISerializedEditorInput[] = this.history.map((input: EditorInput) => {
-			const factory = this.registry.getEditorInputFactory(input.getTypeId());
-			if (factory) {
-				const value = factory.serialize(input);
-				if (typeof value === 'string') {
-					return {
-						id: input.getTypeId(),
-						value: value
-					};
-				}
+		const entries: ISerializedFileEditorInput[] = this.history.map(input => {
+			if (input instanceof EditorInput) {
+				return void 0; // only file resource inputs are serializable currently
 			}
 
-			return void 0;
+			return { resource: (input as IResourceInput).resource.toString() };
 		}).filter(serialized => !!serialized);
 
 		this.storageService.store(HistoryService.STORAGE_KEY, JSON.stringify(entries), StorageScope.WORKSPACE);
 	}
 
 	private load(): void {
-		let entries: ISerializedEditorInput[] = [];
+		let entries: (ILegacySerializedEditorInput|ISerializedFileEditorInput)[] = [];
+
 		const entriesRaw = this.storageService.get(HistoryService.STORAGE_KEY, StorageScope.WORKSPACE);
 		if (entriesRaw) {
 			entries = JSON.parse(entriesRaw);
 		}
 
 		this.history = entries.map(entry => {
-			const factory = this.registry.getEditorInputFactory(entry.id);
-			if (factory && typeof entry.value === 'string') {
-				return factory.deserialize(this.instantiationService, entry.value);
+			const serializedLegacyInput = entry as ILegacySerializedEditorInput;
+			const serializedFileInput = entry as ISerializedFileEditorInput;
+
+			// Legacy support (TODO@Ben remove me - migration)
+			if (serializedLegacyInput.id) {
+				const factory = this.registry.getEditorInputFactory(serializedLegacyInput.id);
+				if (factory && typeof serializedLegacyInput.value === 'string') {
+					const fileInput = asFileEditorInput(factory.deserialize(this.instantiationService, serializedLegacyInput.value));
+					if (fileInput) {
+						return { resource: fileInput.getResource() } as IResourceInput;
+					}
+
+					return void 0;
+				}
+			}
+
+			// New resource input support
+			else if (serializedFileInput.resource) {
+				return { resource: URI.parse(serializedFileInput.resource) } as IResourceInput;
 			}
 
 			return void 0;

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

@@ -5,7 +5,7 @@
 'use strict';
 
 import {createDecorator, ServiceIdentifier} from 'vs/platform/instantiation/common/instantiation';
-import {IEditorInput, ITextEditorOptions} from 'vs/platform/editor/common/editor';
+import {IEditorInput, ITextEditorOptions, IResourceInput} from 'vs/platform/editor/common/editor';
 
 export const IHistoryService = createDecorator<IHistoryService>('historyService');
 
@@ -46,5 +46,5 @@ export interface IHistoryService {
 	/**
 	 * Get the entire history of opened editors.
 	 */
-	getHistory(): IEditorInput[];
+	getHistory(): (IEditorInput|IResourceInput)[];
 }
\ No newline at end of file