Undo split of serializers into own main thread class

The serializers belong with the panels, not in their own class

src/vs/workbench/api/browser/mainThreadWebviewPanelsAndViews.ts

@@ -3,23 +3,25 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { onUnexpectedError } from 'vs/base/common/errors';
 import { Disposable, DisposableStore, dispose, IDisposable } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { MainThreadCustomEditors } from 'vs/workbench/api/browser/mainThreadCustomEditors';
 import { MainThreadWebviews, reviveWebviewExtension, reviveWebviewOptions } from 'vs/workbench/api/browser/mainThreadWebviews';
-import { MainThreadWebviewSerializers } from 'vs/workbench/api/browser/mainThreadWebviewSerializer';
 import { MainThreadWebviewsViews } from 'vs/workbench/api/browser/mainThreadWebviewViews';
 import * as extHostProtocol from 'vs/workbench/api/common/extHost.protocol';
 import { editorGroupToViewColumn, EditorViewColumn, viewColumnToEditorGroup } from 'vs/workbench/api/common/shared/editor';
 import { IEditorInput } from 'vs/workbench/common/editor';
 import { DiffEditorInput } from 'vs/workbench/common/editor/diffEditorInput';
+import { CustomEditorInput } from 'vs/workbench/contrib/customEditor/browser/customEditorInput';
 import { WebviewIcons } from 'vs/workbench/contrib/webview/browser/webview';
 import { WebviewInput } from 'vs/workbench/contrib/webview/browser/webviewEditorInput';
 import { ICreateWebViewShowOptions, IWebviewWorkbenchService, WebviewInputOptions } from 'vs/workbench/contrib/webview/browser/webviewWorkbenchService';
 import { IEditorGroup, IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 import { extHostNamedCustomer } from '../common/extHostCustomers';
 
 /**
@@ -78,9 +80,10 @@ class WebviewViewTypeTransformer {
 @extHostNamedCustomer(extHostProtocol.MainContext.MainThreadWebviewService)
 export class MainThreadWebviewPanelsAndViews extends Disposable implements extHostProtocol.MainThreadWebviewPanelsAndViewsShape {
 
-	public readonly webviewPanelViewType = new WebviewViewTypeTransformer('mainThreadWebview-');
+	private readonly webviewPanelViewType = new WebviewViewTypeTransformer('mainThreadWebview-');
 
 	private readonly _proxy: extHostProtocol.ExtHostWebviewsShape;
+	private readonly _proxyPanels: extHostProtocol.ExtHostWebviewPanelsShape;
 
 	private readonly _webviewInputs = new WebviewInputStore();
 
@@ -89,10 +92,11 @@ export class MainThreadWebviewPanelsAndViews extends Disposable implements extHo
 
 	private readonly _mainThreadWebviews: MainThreadWebviews;
 
-	private readonly serializers: MainThreadWebviewSerializers;
+	private readonly _revivers = new Map<string, IDisposable>();
 
 	constructor(
 		context: extHostProtocol.IExtHostContext,
+		@IExtensionService extensionService: IExtensionService,
 		@IEditorGroupsService private readonly _editorGroupService: IEditorGroupsService,
 		@IEditorService private readonly _editorService: IEditorService,
 		@ITelemetryService private readonly _telemetryService: ITelemetryService,
@@ -102,6 +106,7 @@ export class MainThreadWebviewPanelsAndViews extends Disposable implements extHo
 		super();
 
 		this._proxy = context.getProxy(extHostProtocol.ExtHostContext.ExtHostWebviews);
+		this._proxyPanels = context.getProxy(extHostProtocol.ExtHostContext.ExtHostWebviewPanels);
 
 		this._mainThreadWebviews = this._instantiationService.createInstance(MainThreadWebviews, context);
 		context.set(extHostProtocol.MainContext.MainThreadWebviews, this._mainThreadWebviews);
@@ -112,8 +117,6 @@ export class MainThreadWebviewPanelsAndViews extends Disposable implements extHo
 		const customEditors = this._instantiationService.createInstance(MainThreadCustomEditors, this._mainThreadWebviews, this, context);
 		context.set(extHostProtocol.MainContext.MainThreadCustomEditors, customEditors);
 
-		this.serializers = this._instantiationService.createInstance(MainThreadWebviewSerializers, this._mainThreadWebviews, this, context);
-
 		this._register(_editorService.onDidActiveEditorChange(() => {
 			const activeInput = this._editorService.activeEditor;
 			if (activeInput instanceof DiffEditorInput && activeInput.primary instanceof WebviewInput && activeInput.secondary instanceof WebviewInput) {
@@ -126,6 +129,24 @@ export class MainThreadWebviewPanelsAndViews extends Disposable implements extHo
 		this._register(_editorService.onDidVisibleEditorsChange(() => {
 			this.updateWebviewViewStates(this._editorService.activeEditor);
 		}));
+
+		// This reviver's only job is to activate extensions.
+		// This should trigger the real reviver to be registered from the extension host side.
+		this._register(_webviewWorkbenchService.registerResolver({
+			canResolve: (webview: WebviewInput) => {
+				if (webview instanceof CustomEditorInput) {
+					extensionService.activateByEvent(`onCustomEditor:${webview.viewType}`);
+					return false;
+				}
+
+				const viewType = this.webviewPanelViewType.toExternal(webview.viewType);
+				if (typeof viewType === 'string') {
+					extensionService.activateByEvent(`onWebviewPanel:${viewType}`);
+				}
+				return false;
+			},
+			resolveWebview: () => { throw new Error('not implemented'); }
+		}));
 	}
 
 	dispose() {
@@ -205,12 +226,55 @@ export class MainThreadWebviewPanelsAndViews extends Disposable implements extHo
 		}
 	}
 
-	public $registerSerializer(viewType: string): void {
-		this.serializers.$registerSerializer(viewType);
+	public $registerSerializer(viewType: string)
+		: void {
+		if (this._revivers.has(viewType)) {
+			throw new Error(`Reviver for ${viewType} already registered`);
+		}
+
+		this._revivers.set(viewType, this._webviewWorkbenchService.registerResolver({
+			canResolve: (webviewInput) => {
+				return webviewInput.viewType === this.webviewPanelViewType.fromExternal(viewType);
+			},
+			resolveWebview: async (webviewInput): Promise<void> => {
+				const viewType = this.webviewPanelViewType.toExternal(webviewInput.viewType);
+				if (!viewType) {
+					webviewInput.webview.html = this._mainThreadWebviews.getWebviewResolvedFailedContent(webviewInput.viewType);
+					return;
+				}
+
+
+				const handle = webviewInput.id;
+
+				this.addWebviewInput(handle, webviewInput);
+
+				let state = undefined;
+				if (webviewInput.webview.state) {
+					try {
+						state = JSON.parse(webviewInput.webview.state);
+					} catch (e) {
+						console.error('Could not load webview state', e, webviewInput.webview.state);
+					}
+				}
+
+				try {
+					await this._proxyPanels.$deserializeWebviewPanel(handle, viewType, webviewInput.getTitle(), state, editorGroupToViewColumn(this._editorGroupService, webviewInput.group || 0), webviewInput.webview.options);
+				} catch (error) {
+					onUnexpectedError(error);
+					webviewInput.webview.html = this._mainThreadWebviews.getWebviewResolvedFailedContent(viewType);
+				}
+			}
+		}));
 	}
 
 	public $unregisterSerializer(viewType: string): void {
-		this.serializers.$unregisterSerializer(viewType);
+		const reviver = this._revivers.get(viewType);
+		if (!reviver) {
+			throw new Error(`No reviver for ${viewType} registered`);
+		}
+
+		reviver.dispose();
+		this._revivers.delete(viewType);
 	}
 
 	private registerWebviewFromDiffEditorListeners(diffEditorInput: DiffEditorInput): void {

src/vs/workbench/api/browser/mainThreadWebviewSerializer.ts

-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { onUnexpectedError } from 'vs/base/common/errors';
-import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
-import type { MainThreadWebviewPanelsAndViews } from 'vs/workbench/api/browser/mainThreadWebviewPanelsAndViews';
-import { MainThreadWebviews } from 'vs/workbench/api/browser/mainThreadWebviews';
-import * as extHostProtocol from 'vs/workbench/api/common/extHost.protocol';
-import { editorGroupToViewColumn } from 'vs/workbench/api/common/shared/editor';
-import { CustomEditorInput } from 'vs/workbench/contrib/customEditor/browser/customEditorInput';
-import { WebviewInput } from 'vs/workbench/contrib/webview/browser/webviewEditorInput';
-import { IWebviewWorkbenchService } from 'vs/workbench/contrib/webview/browser/webviewWorkbenchService';
-import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
-import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
-
-export class MainThreadWebviewSerializers extends Disposable {
-
-	private readonly _proxy: extHostProtocol.ExtHostWebviewSerializerShape;
-
-	private readonly _revivers = new Map<string, IDisposable>();
-
-	constructor(
-		private readonly mainThreadWebviews: MainThreadWebviews,
-		private readonly mainThreadWebviewsPanelsAndViews: MainThreadWebviewPanelsAndViews,
-		context: extHostProtocol.IExtHostContext,
-		@IExtensionService extensionService: IExtensionService,
-		@IEditorGroupsService private readonly _editorGroupService: IEditorGroupsService,
-		@IWebviewWorkbenchService private readonly _webviewWorkbenchService: IWebviewWorkbenchService,
-	) {
-		super();
-
-		this._proxy = context.getProxy(extHostProtocol.ExtHostContext.ExtHostWebviewSerializer);
-
-		// This reviver's only job is to activate extensions.
-		// This should trigger the real reviver to be registered from the extension host side.
-		this._register(_webviewWorkbenchService.registerResolver({
-			canResolve: (webview: WebviewInput) => {
-				if (webview instanceof CustomEditorInput) {
-					extensionService.activateByEvent(`onCustomEditor:${webview.viewType}`);
-					return false;
-				}
-
-				const viewType = this.mainThreadWebviewsPanelsAndViews.webviewPanelViewType.toExternal(webview.viewType);
-				if (typeof viewType === 'string') {
-					extensionService.activateByEvent(`onWebviewPanel:${viewType}`);
-				}
-				return false;
-			},
-			resolveWebview: () => { throw new Error('not implemented'); }
-		}));
-	}
-
-	public $registerSerializer(viewType: string)
-		: void {
-		if (this._revivers.has(viewType)) {
-			throw new Error(`Reviver for ${viewType} already registered`);
-		}
-
-		this._revivers.set(viewType, this._webviewWorkbenchService.registerResolver({
-			canResolve: (webviewInput) => {
-				return webviewInput.viewType === this.mainThreadWebviewsPanelsAndViews.webviewPanelViewType.fromExternal(viewType);
-			},
-			resolveWebview: async (webviewInput): Promise<void> => {
-				const viewType = this.mainThreadWebviewsPanelsAndViews.webviewPanelViewType.toExternal(webviewInput.viewType);
-				if (!viewType) {
-					webviewInput.webview.html = this.mainThreadWebviews.getWebviewResolvedFailedContent(webviewInput.viewType);
-					return;
-				}
-
-
-				const handle = webviewInput.id;
-
-				this.mainThreadWebviewsPanelsAndViews.addWebviewInput(handle, webviewInput);
-
-				let state = undefined;
-				if (webviewInput.webview.state) {
-					try {
-						state = JSON.parse(webviewInput.webview.state);
-					} catch (e) {
-						console.error('Could not load webview state', e, webviewInput.webview.state);
-					}
-				}
-
-				try {
-					await this._proxy.$deserializeWebviewPanel(handle, viewType, webviewInput.getTitle(), state, editorGroupToViewColumn(this._editorGroupService, webviewInput.group || 0), webviewInput.webview.options);
-				} catch (error) {
-					onUnexpectedError(error);
-					webviewInput.webview.html = this.mainThreadWebviews.getWebviewResolvedFailedContent(viewType);
-				}
-			}
-		}));
-	}
-
-	public $unregisterSerializer(viewType: string): void {
-		const reviver = this._revivers.get(viewType);
-		if (!reviver) {
-			throw new Error(`No reviver for ${viewType} registered`);
-		}
-
-		reviver.dispose();
-		this._revivers.delete(viewType);
-	}
-}

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

@@ -145,7 +145,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const extHostAuthentication = rpcProtocol.set(ExtHostContext.ExtHostAuthentication, new ExtHostAuthentication(rpcProtocol));
 	const extHostTimeline = rpcProtocol.set(ExtHostContext.ExtHostTimeline, new ExtHostTimeline(rpcProtocol, extHostCommands));
 	const extHostWebviews = rpcProtocol.set(ExtHostContext.ExtHostWebviews, new ExtHostWebviews(rpcProtocol, initData.environment, extHostWorkspace, extHostLogService, extHostApiDeprecation));
-	const extHostWebviewSerializers = rpcProtocol.set(ExtHostContext.ExtHostWebviewSerializer, new ExtHostWebviewSerializer(rpcProtocol, extHostWebviews));
+	const extHostWebviewSerializers = rpcProtocol.set(ExtHostContext.ExtHostWebviewPanels, new ExtHostWebviewSerializer(rpcProtocol, extHostWebviews));
 	const extHostCustomEditors = rpcProtocol.set(ExtHostContext.ExtHostCustomEditors, new ExtHostCustomEditors(rpcProtocol, extHostDocuments, extensionStoragePaths, extHostWebviews));
 	const extHostWebviewViews = rpcProtocol.set(ExtHostContext.ExtHostWebviewViews, new ExtHostWebviewViews(rpcProtocol, extHostWebviews));
 

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

@@ -656,7 +656,7 @@ export interface ExtHostWebviewsShape {
 	$onDidDisposeWebviewPanel(handle: WebviewPanelHandle): Promise<void>;
 }
 
-export interface ExtHostWebviewSerializerShape {
+export interface ExtHostWebviewPanelsShape {
 	$deserializeWebviewPanel(newWebviewHandle: WebviewPanelHandle, viewType: string, title: string, state: any, position: EditorViewColumn, options: modes.IWebviewOptions & modes.IWebviewPanelOptions): Promise<void>;
 }
 
@@ -1764,7 +1764,7 @@ export const ExtHostContext = {
 	ExtHostWorkspace: createExtId<ExtHostWorkspaceShape>('ExtHostWorkspace'),
 	ExtHostWindow: createExtId<ExtHostWindowShape>('ExtHostWindow'),
 	ExtHostWebviews: createExtId<ExtHostWebviewsShape>('ExtHostWebviews'),
-	ExtHostWebviewSerializer: createExtId<ExtHostWebviewSerializerShape>('ExtHostWebviewSerializer'),
+	ExtHostWebviewPanels: createExtId<ExtHostWebviewPanelsShape>('ExtHostWebviewPanels'),
 	ExtHostCustomEditors: createExtId<ExtHostCustomEditorsShape>('ExtHostCustomEditors'),
 	ExtHostWebviewViews: createExtId<ExtHostWebviewViewsShape>('ExtHostWebviewViews'),
 	ExtHostEditorInsets: createExtId<ExtHostEditorInsetsShape>('ExtHostEditorInsets'),

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

@@ -11,7 +11,7 @@ import type * as vscode from 'vscode';
 import * as extHostProtocol from './extHost.protocol';
 import * as extHostTypes from './extHostTypes';
 
-export class ExtHostWebviewSerializer implements extHostProtocol.ExtHostWebviewSerializerShape {
+export class ExtHostWebviewSerializer implements extHostProtocol.ExtHostWebviewPanelsShape {
 
 	private readonly _proxy: extHostProtocol.MainThreadWebviewPanelsAndViewsShape;