Keep a local tree at extHostExplorer side

src/vs/workbench/api/node/extHost.protocol.ts

@@ -34,6 +34,8 @@ import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
 import { IWorkspaceSymbol } from 'vs/workbench/parts/search/common/search';
 import { IApplyEditsOptions, TextEditorRevealType, ITextEditorConfigurationUpdate, IResolvedTextEditorConfiguration, ISelectionChangeEvent } from './mainThreadEditorsTracker';
 
+import { ExtHostTreeNode } from 'vs/workbench/api/node/extHostExplorers';
+
 export interface InstanceSetter<T> {
 	set<R extends T>(instance: T): R;
 }
@@ -263,8 +265,8 @@ export abstract class ExtHostEditorsShape {
 }
 
 export abstract class ExtHostExplorersShape {
-	$provideTreeContent(treeContentProviderId: string): TPromise<vscode.ITreeNode> { throw ni(); };
-	$resolveChildren(treeContentProviderId: string, node: vscode.ITreeNode): TPromise<vscode.ITreeNode[]> { throw ni(); }
+	$provideTreeContent(treeContentProviderId: string): TPromise<ExtHostTreeNode> { throw ni(); };
+	$resolveChildren(treeContentProviderId: string, node: ExtHostTreeNode): TPromise<ExtHostTreeNode[]> { throw ni(); }
 }
 
 export abstract class ExtHostExtensionServiceShape {

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as vscode from 'vscode';
+import { ITreeNode, TreeContentProvider } from 'vscode';
 import {TPromise} from 'vs/base/common/winjs.base';
 import {Disposable} from 'vs/workbench/api/node/extHostTypes';
 import {IThreadService} from 'vs/workbench/services/thread/common/threadService';
@@ -13,7 +13,9 @@ import {MainContext, ExtHostExplorersShape, MainThreadExplorersShape} from './ex
 export class ExtHostExplorers extends ExtHostExplorersShape {
 	private _proxy: MainThreadExplorersShape;
 
-	private _treeContentProviders: { [treeContentProviderId: string]: vscode.TreeContentProvider };
+	private _treeContentProviders: { [treeContentProviderId: string]: TreeContentProvider };
+	private _treeContents: { [treeContentProviderId: string]: ExtHostTreeNode };
+	private _treeNodeMaps: { [treeContentProviderId: string]: { [id: number]: ExtHostTreeNode }};
 
 	constructor(
 		threadService: IThreadService
@@ -23,9 +25,11 @@ export class ExtHostExplorers extends ExtHostExplorersShape {
 		this._proxy = threadService.get(MainContext.MainThreadExplorers);
 
 		this._treeContentProviders = Object.create(null);
+		this._treeContents = Object.create(null);
+		this._treeNodeMaps = Object.create(null);
 	}
 
-	registerTreeContentProvider(providerId: string, provider: vscode.TreeContentProvider): vscode.Disposable {
+	registerTreeContentProvider(providerId: string, provider: TreeContentProvider): Disposable {
 		this._proxy.$registerTreeContentProvider(providerId);
 		this._treeContentProviders[providerId] = provider;
 
@@ -36,25 +40,56 @@ export class ExtHostExplorers extends ExtHostExplorersShape {
 		});
 	}
 
-	$provideTreeContent(treeContentProviderId: string): TPromise<vscode.ITreeNode> {
+	$provideTreeContent(treeContentProviderId: string): TPromise<ExtHostTreeNode> {
 		const provider = this._treeContentProviders[treeContentProviderId];
 		if (!provider) {
 			throw new Error(`no TreeContentProvider registered with id '${treeContentProviderId}'`);
 		}
 
 		return TPromise.wrap(provider.provideTreeContent().then(treeContent => {
-			return treeContent;
+			const treeNodeMap = Object.create(null);
+			this._treeNodeMaps[treeContentProviderId] = treeNodeMap;
+			this._treeContents[treeContentProviderId] = new ExtHostTreeNode(treeContent, null, treeNodeMap);
+			return this._treeContents[treeContentProviderId];
 		}));
 	}
 
-	$resolveChildren(treeContentProviderId: string, node: vscode.ITreeNode): TPromise<vscode.ITreeNode[]> {
+	$resolveChildren(treeContentProviderId: string, mainThreadNode: ExtHostTreeNode): TPromise<ExtHostTreeNode[]> {
 		const provider = this._treeContentProviders[treeContentProviderId];
 		if (!provider) {
 			throw new Error(`no TreeContentProvider registered with id '${treeContentProviderId}'`);
 		}
 
-		return TPromise.wrap(provider.resolveChildren(node).then(children => {
-			return children;
+		const treeNodeMap = this._treeNodeMaps[treeContentProviderId];
+		const extHostNode = treeNodeMap[mainThreadNode.id];
+
+		return TPromise.wrap(provider.resolveChildren(extHostNode).then(children => {
+			extHostNode.children = children.map(child => {
+				return new ExtHostTreeNode(child, extHostNode, treeNodeMap);
+			});
+			return extHostNode.children;
 		}));
 	}
 }
+
+export class ExtHostTreeNode implements ITreeNode {
+	static idCounter = 1;
+
+	id: number;
+
+	label: string;
+	isExpanded: boolean;
+	children: ExtHostTreeNode[];
+
+	constructor(node: ITreeNode, parent: ExtHostTreeNode, treeNodeMap: { [id: number]: ExtHostTreeNode}) {
+		this.id = ExtHostTreeNode.idCounter++;
+
+		this.label = node.label;
+		this.isExpanded = node.isExpanded;
+		this.children = node.children.map(child => {
+			return new ExtHostTreeNode(child, this, treeNodeMap);
+		})
+
+		treeNodeMap[this.id] = this;
+	}
+}
\ No newline at end of file

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

@@ -11,9 +11,13 @@ import {ExtHostContext, MainThreadExplorersShape, ExtHostExplorersShape} from '.
 import {ITreeExplorerViewletService} from 'vs/workbench/parts/explorers/browser/treeExplorerViewletService';
 import {TreeViewNode} from 'vs/workbench/parts/explorers/common/treeViewModel';
 
+import { ExtHostTreeNode } from 'vs/workbench/api/node/extHostExplorers';
+
 export class MainThreadExplorers extends MainThreadExplorersShape {
 	private _proxy: ExtHostExplorersShape;
 
+	private _treeContents: { [treeContentProviderId: string]: ExtHostTreeNode };
+
 	constructor(
 		@IThreadService threadService: IThreadService,
 		@ITreeExplorerViewletService private treeExplorerViewletService: ITreeExplorerViewletService
@@ -21,14 +25,18 @@ export class MainThreadExplorers extends MainThreadExplorersShape {
 		super();
 
 		this._proxy = threadService.get(ExtHostContext.ExtHostExplorers);
+		this._treeContents = Object.create(null);
 	}
 
 	$registerTreeContentProvider(providerId: string): void {
 		this.treeExplorerViewletService.registerTreeContentProvider(providerId, {
-			provideTreeContent: (): TPromise<ITreeNode> => {
-				return this._proxy.$provideTreeContent(providerId);
+			provideTreeContent: (): TPromise<ExtHostTreeNode> => {
+				return this._proxy.$provideTreeContent(providerId).then(treeContent => {
+					this._treeContents[providerId] = treeContent;
+					return treeContent;
+				})
 			},
-			resolveChildren: (node: ITreeNode): TPromise<ITreeNode[]> => {
+			resolveChildren: (node: ExtHostTreeNode): TPromise<ExtHostTreeNode[]> => {
 				return this._proxy.$resolveChildren(providerId, node);
 			}
 		});