Merge branch 'master' into sandy081/userDataProvider

src/vs/workbench/api/common/extHost.api.impl.ts

@@ -525,6 +525,10 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			registerWebviewPanelSerializer: (viewType: string, serializer: vscode.WebviewPanelSerializer) => {
 				return extHostWebviews.registerWebviewPanelSerializer(viewType, serializer);
 			},
+			registerWebviewEditorProvider: (viewType: string, provider: vscode.WebviewEditorProvider) => {
+				checkProposedApiEnabled(extension);
+				return extHostWebviews.registerWebviewEditorProvider(viewType, provider);
+			},
 			registerDecorationProvider(provider: vscode.DecorationProvider) {
 				checkProposedApiEnabled(extension);
 				return extHostDecorations.registerDecorationProvider(provider, extension.identifier);

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

@@ -250,6 +250,7 @@ export interface MainThreadTreeViewsShape extends IDisposable {
 	$refresh(treeViewId: string, itemsToRefresh?: { [treeItemHandle: string]: ITreeItem }): Promise<void>;
 	$reveal(treeViewId: string, treeItem: ITreeItem, parentChain: ITreeItem[], options: IRevealOptions): Promise<void>;
 	$setMessage(treeViewId: string, message: string): void;
+	$setTitle(treeViewId: string, title: string): void;
 }
 
 export interface MainThreadDownloadServiceShape extends IDisposable {
@@ -554,6 +555,9 @@ export interface MainThreadWebviewsShape extends IDisposable {
 
 	$registerSerializer(viewType: string): void;
 	$unregisterSerializer(viewType: string): void;
+
+	$registerEditorProvider(viewType: string): void;
+	$unregisterEditorProvider(viewType: string): void;
 }
 
 export interface WebviewPanelViewStateData {
@@ -570,6 +574,7 @@ export interface ExtHostWebviewsShape {
 	$onDidChangeWebviewPanelViewStates(newState: WebviewPanelViewStateData): void;
 	$onDidDisposeWebviewPanel(handle: WebviewPanelHandle): Promise<void>;
 	$deserializeWebviewPanel(newWebviewHandle: WebviewPanelHandle, viewType: string, title: string, state: any, position: EditorViewColumn, options: modes.IWebviewOptions & modes.IWebviewPanelOptions): Promise<void>;
+	$resolveWebviewEditor(resource: UriComponents, newWebviewHandle: WebviewPanelHandle, viewType: string, title: string, state: any, position: EditorViewColumn, options: modes.IWebviewOptions & modes.IWebviewPanelOptions): Promise<void>;
 }
 
 export interface MainThreadUrlsShape extends IDisposable {

src/vs/workbench/api/common/extHostTreeViews.ts

@@ -96,6 +96,11 @@ export class ExtHostTreeViews implements ExtHostTreeViewsShape {
 				checkProposedApiEnabled(extension);
 				treeView.message = message;
 			},
+			get title() { return treeView.title; },
+			set title(title: string) {
+				checkProposedApiEnabled(extension);
+				treeView.title = title;
+			},
 			reveal: (element: T, options?: IRevealOptions): Promise<void> => {
 				return treeView.reveal(element, options);
 			},
@@ -195,6 +200,15 @@ class ExtHostTreeView<T> extends Disposable {
 
 	constructor(private viewId: string, options: vscode.TreeViewOptions<T>, private proxy: MainThreadTreeViewsShape, private commands: CommandsConverter, private logService: ILogService, private extension: IExtensionDescription) {
 		super();
+		if (extension.contributes && extension.contributes.views) {
+			for (const location in extension.contributes.views) {
+				for (const view of extension.contributes.views[location]) {
+					if (view.id === viewId) {
+						this._title = view.name;
+					}
+				}
+			}
+		}
 		this.dataProvider = options.treeDataProvider;
 		this.proxy.$registerTreeViewDataProvider(viewId, { showCollapseAll: !!options.showCollapseAll, canSelectMany: !!options.canSelectMany });
 		if (this.dataProvider.onDidChangeTreeData) {
@@ -274,6 +288,16 @@ class ExtHostTreeView<T> extends Disposable {
 		this._onDidChangeData.fire({ message: true, element: false });
 	}
 
+	private _title: string = '';
+	get title(): string {
+		return this._title;
+	}
+
+	set title(title: string) {
+		this._title = title;
+		this.proxy.$setTitle(this.viewId, title);
+	}
+
 	setExpanded(treeItemHandle: TreeItemHandle, expanded: boolean): void {
 		const element = this.getExtensionElement(treeItemHandle);
 		if (element) {

src/vs/workbench/api/common/extHostWebview.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Emitter, Event } from 'vs/base/common/event';
-import { URI } from 'vs/base/common/uri';
+import { URI, UriComponents } from 'vs/base/common/uri';
 import { generateUuid } from 'vs/base/common/uuid';
 import * as modes from 'vs/editor/common/modes';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
@@ -241,6 +241,7 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 	private readonly _proxy: MainThreadWebviewsShape;
 	private readonly _webviewPanels = new Map<WebviewPanelHandle, ExtHostWebviewPanel>();
 	private readonly _serializers = new Map<string, vscode.WebviewPanelSerializer>();
+	private readonly _editorProviders = new Map<string, vscode.WebviewEditorProvider>();
 
 	constructor(
 		mainContext: IMainContext,
@@ -288,6 +289,23 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 		});
 	}
 
+	public registerWebviewEditorProvider(
+		viewType: string,
+		provider: vscode.WebviewEditorProvider
+	): vscode.Disposable {
+		if (this._editorProviders.has(viewType)) {
+			throw new Error(`Editor provider for '${viewType}' already registered`);
+		}
+
+		this._editorProviders.set(viewType, provider);
+		this._proxy.$registerEditorProvider(viewType);
+
+		return new Disposable(() => {
+			this._editorProviders.delete(viewType);
+			this._proxy.$unregisterEditorProvider(viewType);
+		});
+	}
+
 	public $onMessage(
 		handle: WebviewPanelHandle,
 		message: any
@@ -371,6 +389,27 @@ export class ExtHostWebviews implements ExtHostWebviewsShape {
 	private getWebviewPanel(handle: WebviewPanelHandle): ExtHostWebviewPanel | undefined {
 		return this._webviewPanels.get(handle);
 	}
+
+	async $resolveWebviewEditor(
+		resource: UriComponents,
+		webviewHandle: WebviewPanelHandle,
+		viewType: string,
+		title: string,
+		state: any,
+		position: EditorViewColumn,
+		options: modes.IWebviewOptions & modes.IWebviewPanelOptions
+	): Promise<void> {
+		const provider = this._editorProviders.get(viewType);
+		if (!provider) {
+			return Promise.reject(new Error(`No provider found for '${viewType}'`));
+		}
+
+		const webview = new ExtHostWebview(webviewHandle, this._proxy, options, this.initData);
+		const revivedPanel = new ExtHostWebviewPanel(webviewHandle, this._proxy, viewType, title, typeof position === 'number' && position >= 0 ? typeConverters.ViewColumn.to(position) : undefined, options, webview);
+		this._webviewPanels.set(webviewHandle, revivedPanel);
+		return Promise.resolve(provider.resolveWebviewEditor(URI.revive(resource), revivedPanel));
+	}
+
 }
 
 function convertWebviewOptions(