Merge remote-tracking branch 'origin/master' into joao/submenus

2026-04-23 01:58:53 +01:00 · 2020-07-21 14:39:02 +02:00
parent 6584270727 288108c294
commit 18e9e7f32d
211 changed files with 3063 additions and 1893 deletions
--- a/src/vs/workbench/api/browser/mainThreadAuthentication.ts
+++ b/src/vs/workbench/api/browser/mainThreadAuthentication.ts
@@ -17,6 +17,7 @@ import { INotificationService } from 'vs/platform/notification/common/notificati
 import { IStorageKeysSyncRegistryService } from 'vs/platform/userDataSync/common/storageKeys';
 import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
 import { fromNow } from 'vs/base/common/date';
+import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';

 const VSO_ALLOWED_EXTENSIONS = ['github.vscode-pull-request-github', 'github.vscode-pull-request-github-insiders', 'vscode.git', 'ms-vsonline.vsonline', 'vscode.github-browser'];

@@ -213,7 +214,8 @@ export class MainThreadAuthentication extends Disposable implements MainThreadAu
 		@INotificationService private readonly notificationService: INotificationService,
 		@IStorageKeysSyncRegistryService private readonly storageKeysSyncRegistryService: IStorageKeysSyncRegistryService,
 		@IRemoteAgentService private readonly remoteAgentService: IRemoteAgentService,
-		@IQuickInputService private readonly quickInputService: IQuickInputService
+		@IQuickInputService private readonly quickInputService: IQuickInputService,
+		@IExtensionService private readonly extensionService: IExtensionService
 	) {
 		super();
 		this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostAuthentication);
@@ -292,7 +294,7 @@ export class MainThreadAuthentication extends Disposable implements MainThreadAu
 				}

 				const session = await this.authenticationService.login(providerId, scopes);
-				await this.$setTrustedExtension(providerId, session.account.label, extensionId, extensionName);
+				await this.$setTrustedExtensionAndAccountPreference(providerId, session.account.label, extensionId, extensionName, session.id);
 				return session;
 			} else {
 				await this.$requestNewSession(providerId, scopes, extensionId, extensionName);
@@ -378,6 +380,8 @@ export class MainThreadAuthentication extends Disposable implements MainThreadAu
 	}

 	async $getSessionsPrompt(providerId: string, accountName: string, providerName: string, extensionId: string, extensionName: string): Promise<boolean> {
+		await this.extensionService.activateByEvent(`onAuthenticationRequest:${providerId}`);
+
 		const allowList = readAllowedExtensions(this.storageService, providerId, accountName);
 		const extensionData = allowList.find(extension => extension.id === extensionId);
 		if (extensionData) {
@@ -423,11 +427,13 @@ export class MainThreadAuthentication extends Disposable implements MainThreadAu
 		return choice === 0;
 	}

-	async $setTrustedExtension(providerId: string, accountName: string, extensionId: string, extensionName: string): Promise<void> {
+	async $setTrustedExtensionAndAccountPreference(providerId: string, accountName: string, extensionId: string, extensionName: string, sessionId: string): Promise<void> {
 		const allowList = readAllowedExtensions(this.storageService, providerId, accountName);
 		if (!allowList.find(allowed => allowed.id === extensionId)) {
 			allowList.push({ id: extensionId, name: extensionName });
 			this.storageService.store(`${providerId}-${accountName}`, JSON.stringify(allowList), StorageScope.GLOBAL);
 		}
+
+		this.storageService.store(`${extensionName}-${providerId}`, sessionId, StorageScope.GLOBAL);
 	}
 }
--- a/src/vs/workbench/api/browser/mainThreadNotebook.ts
+++ b/src/vs/workbench/api/browser/mainThreadNotebook.ts
@@ -3,14 +3,13 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import * as nls from 'vs/nls';
 import * as DOM from 'vs/base/browser/dom';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
-import { MainContext, MainThreadNotebookShape, NotebookExtensionDescription, IExtHostContext, ExtHostNotebookShape, ExtHostContext, INotebookDocumentsAndEditorsDelta, INotebookModelAddedData } from '../common/extHost.protocol';
-import { Disposable, IDisposable, combinedDisposable } from 'vs/base/common/lifecycle';
+import { MainContext, MainThreadNotebookShape, NotebookExtensionDescription, IExtHostContext, ExtHostNotebookShape, ExtHostContext, INotebookDocumentsAndEditorsDelta } from '../common/extHost.protocol';
+import { Disposable, IDisposable, combinedDisposable, DisposableStore } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { INotebookService, IMainNotebookController } from 'vs/workbench/contrib/notebook/common/notebookService';
-import { INotebookTextModel, INotebookMimeTypeSelector, NOTEBOOK_DISPLAY_ORDER, NotebookCellOutputsSplice, NotebookDocumentMetadata, NotebookCellMetadata, ICellEditOperation, ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER, CellEditType, CellKind, INotebookKernelInfo, INotebookKernelInfoDto, INotebookTextModelBackup, IEditor, INotebookRendererInfo, IOutputRenderRequest, IOutputRenderResponse, INotebookDocumentFilter } from 'vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookMimeTypeSelector, NOTEBOOK_DISPLAY_ORDER, NotebookCellOutputsSplice, NotebookDocumentMetadata, NotebookCellMetadata, ICellEditOperation, ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER, CellEditType, CellKind, INotebookKernelInfo, INotebookKernelInfoDto, IEditor, INotebookRendererInfo, IOutputRenderRequest, IOutputRenderResponse, INotebookDocumentFilter } from 'vs/workbench/contrib/notebook/common/notebookCommon';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { NotebookTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookTextModel';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
@@ -19,8 +18,7 @@ import { CancellationToken } from 'vs/base/common/cancellation';
 import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility';
 import { IRelativePattern } from 'vs/base/common/glob';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { IUndoRedoService, UndoRedoElementType } from 'vs/platform/undoRedo/common/undoRedo';
+import { IUndoRedoService } from 'vs/platform/undoRedo/common/undoRedo';
 import { ITextModelService } from 'vs/editor/common/services/resolverService';
 import { Emitter } from 'vs/base/common/event';

@@ -55,42 +53,8 @@ export class MainThreadNotebookDocument extends Disposable {
 		}));
 	}

-	async applyEdit(modelVersionId: number, edits: ICellEditOperation[], emitToExtHost: boolean, synchronous: boolean): Promise<boolean> {
-		await this.notebookService.transformEditsOutputs(this.textModel, edits);
-		if (synchronous) {
-			return this._textModel.$applyEdit(modelVersionId, edits, emitToExtHost, synchronous);
-		} else {
-			return new Promise(resolve => {
-				this._register(DOM.scheduleAtNextAnimationFrame(() => {
-					const ret = this._textModel.$applyEdit(modelVersionId, edits, emitToExtHost, true);
-					resolve(ret);
-				}));
-			});
-		}
-	}
-
-	async spliceNotebookCellOutputs(cellHandle: number, splices: NotebookCellOutputsSplice[]) {
-		await this.notebookService.transformSpliceOutputs(this.textModel, splices);
-		this._textModel.$spliceNotebookCellOutputs(cellHandle, splices);
-	}
-
-	handleEdit(editId: number, label: string | undefined): void {
-		this.undoRedoService.pushElement({
-			type: UndoRedoElementType.Resource,
-			resource: this._textModel.uri,
-			label: label ?? nls.localize('defaultEditLabel', "Edit"),
-			undo: async () => {
-				await this._proxy.$undoNotebook(this._textModel.viewType, this._textModel.uri, editId, this._textModel.isDirty);
-			},
-			redo: async () => {
-				await this._proxy.$redoNotebook(this._textModel.viewType, this._textModel.uri, editId, this._textModel.isDirty);
-			},
-		});
-		this._textModel.setDirty(true);
-	}
-
 	dispose() {
-		this._textModel.dispose();
+		// this._textModel.dispose();
 		super.dispose();
 	}
 }
@@ -203,21 +167,21 @@ class DocumentAndEditorState {

@extHostNamedCustomer(MainContext.MainThreadNotebook)
 export class MainThreadNotebooks extends Disposable implements MainThreadNotebookShape {
-	private readonly _notebookProviders = new Map<string, MainThreadNotebookController>();
+	private readonly _notebookProviders = new Map<string, IMainNotebookController>();
 	private readonly _notebookKernels = new Map<string, MainThreadNotebookKernel>();
 	private readonly _notebookKernelProviders = new Map<number, { extension: NotebookExtensionDescription, emitter: Emitter<void>, provider: IDisposable }>();
 	private readonly _notebookRenderers = new Map<string, MainThreadNotebookRenderer>();
 	private readonly _proxy: ExtHostNotebookShape;
 	private _toDisposeOnEditorRemove = new Map<string, IDisposable>();
 	private _currentState?: DocumentAndEditorState;
+	private _editorEventListenersMapping: Map<string, DisposableStore> = new Map();

 	constructor(
 		extHostContext: IExtHostContext,
 		@INotebookService private _notebookService: INotebookService,
 		@IConfigurationService private readonly configurationService: IConfigurationService,
 		@IEditorService private readonly editorService: IEditorService,
-		@IAccessibilityService private readonly accessibilityService: IAccessibilityService,
-		@IInstantiationService private readonly _instantiationService: IInstantiationService
+		@IAccessibilityService private readonly accessibilityService: IAccessibilityService

 	) {
 		super();
@@ -226,15 +190,23 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 	}

 	async $tryApplyEdits(viewType: string, resource: UriComponents, modelVersionId: number, edits: ICellEditOperation[], renderers: number[]): Promise<boolean> {
-		let controller = this._notebookProviders.get(viewType);
-
-		if (controller) {
-			return controller.tryApplyEdits(resource, modelVersionId, edits, renderers);
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+		if (textModel) {
+			await this._notebookService.transformEditsOutputs(textModel, edits);
+			return textModel.$applyEdit(modelVersionId, edits, true);
 		}

 		return false;
 	}

+	async removeNotebookTextModel(uri: URI): Promise<void> {
+		// TODO@rebornix, remove cell should use emitDelta as well to ensure document/editor events are sent together
+		await this._proxy.$acceptDocumentAndEditorsDelta({ removedDocuments: [uri] });
+		let textModelDisposableStore = this._editorEventListenersMapping.get(uri.toString());
+		textModelDisposableStore?.dispose();
+		this._editorEventListenersMapping.delete(URI.from(uri).toString());
+	}
+
 	private _isDeltaEmpty(delta: INotebookDocumentsAndEditorsDelta) {
 		if (delta.addedDocuments !== undefined && delta.addedDocuments.length > 0) {
 			return false;
@@ -300,14 +272,39 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 			this._removeNotebookEditor(editors);
 		}));

-		this._register(this._notebookService.onNotebookDocumentAdd(() => {
+		this._register(this._notebookService.onNotebookDocumentAdd((documents) => {
+			documents.forEach(doc => {
+				if (!this._editorEventListenersMapping.has(doc.toString())) {
+					const disposableStore = new DisposableStore();
+					const textModel = this._notebookService.getNotebookTextModel(doc);
+					disposableStore.add(textModel!.onDidModelChangeProxy(e => {
+						this._proxy.$acceptModelChanged(textModel!.uri, e);
+						this._proxy.$acceptEditorPropertiesChanged(doc, { selections: { selections: textModel!.selections }, metadata: null });
+					}));
+					disposableStore.add(textModel!.onDidSelectionChange(e => {
+						const selectionsChange = e ? { selections: e } : null;
+						this._proxy.$acceptEditorPropertiesChanged(doc, { selections: selectionsChange, metadata: null });
+					}));
+
+					this._editorEventListenersMapping.set(textModel!.uri.toString(), disposableStore);
+				}
+			});
 			this._updateState();
 		}));

-		this._register(this._notebookService.onNotebookDocumentRemove(() => {
+		this._register(this._notebookService.onNotebookDocumentRemove((documents) => {
+			documents.forEach(doc => {
+				this._editorEventListenersMapping.get(doc.toString())?.dispose();
+				this._editorEventListenersMapping.delete(doc.toString());
+			});
+
 			this._updateState();
 		}));

+		this._register(this._notebookService.onDidChangeNotebookActiveKernel(e => {
+			this._proxy.$acceptNotebookActiveKernelChange(e);
+		}));
+
 		const updateOrder = () => {
 			let userOrder = this.configurationService.getValue<string[]>('notebook.displayOrder');
 			this._proxy.$acceptDisplayOrder({
@@ -333,10 +330,6 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		this._updateState(notebookEditor);
 	}

-	async addNotebookDocument(data: INotebookModelAddedData) {
-		this._updateState();
-	}
-
 	private _addNotebookEditor(e: IEditor) {
 		this._toDisposeOnEditorRemove.set(e.getId(), combinedDisposable(
 			e.onDidChangeModel(() => this._updateState()),
@@ -425,18 +418,92 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		this._notebookService.unregisterNotebookRenderer(id);
 	}

-	async $registerNotebookProvider(extension: NotebookExtensionDescription, viewType: string, supportBackup: boolean, kernel: INotebookKernelInfoDto | undefined): Promise<void> {
-		let controller = new MainThreadNotebookController(this._proxy, this, viewType, supportBackup, kernel, this._notebookService, this._instantiationService);
-		this._notebookProviders.set(viewType, controller);
-		this._notebookService.registerNotebookController(viewType, extension, controller);
+	async $registerNotebookProvider(_extension: NotebookExtensionDescription, _viewType: string, _supportBackup: boolean, _kernel: INotebookKernelInfoDto | undefined): Promise<void> {
+		const controller: IMainNotebookController = {
+			kernel: _kernel,
+			supportBackup: _supportBackup,
+			reloadNotebook: async (mainthreadTextModel: NotebookTextModel) => {
+				const data = await this._proxy.$resolveNotebookData(_viewType, mainthreadTextModel.uri);
+				if (!data) {
+					return;
+				}
+
+				mainthreadTextModel.languages = data.languages;
+				mainthreadTextModel.metadata = data.metadata;
+
+				const edits: ICellEditOperation[] = [
+					{ editType: CellEditType.Delete, count: mainthreadTextModel.cells.length, index: 0 },
+					{ editType: CellEditType.Insert, index: 0, cells: data.cells }
+				];
+
+				await this._notebookService.transformEditsOutputs(mainthreadTextModel, edits);
+				await new Promise(resolve => {
+					DOM.scheduleAtNextAnimationFrame(() => {
+						const ret = mainthreadTextModel!.$applyEdit(mainthreadTextModel!.versionId, edits, true);
+						resolve(ret);
+					});
+				});
+			},
+			createNotebook: async (textModel: NotebookTextModel, backupId?: string) => {
+				// open notebook document
+				const data = await this._proxy.$resolveNotebookData(textModel.viewType, textModel.uri, backupId);
+				if (!data) {
+					return;
+				}
+
+				textModel.languages = data.languages;
+				textModel.metadata = data.metadata;
+
+				if (data.cells.length) {
+					textModel.initialize(data!.cells);
+				} else {
+					const mainCell = textModel.createCellTextModel([''], textModel.languages.length ? textModel.languages[0] : '', CellKind.Code, [], undefined);
+					textModel.insertTemplateCell(mainCell);
+				}
+
+				this._proxy.$acceptEditorPropertiesChanged(textModel.uri, { selections: null, metadata: textModel.metadata });
+				return;
+			},
+			resolveNotebookEditor: async (viewType: string, uri: URI, editorId: string) => {
+				await this._proxy.$resolveNotebookEditor(viewType, uri, editorId);
+			},
+			executeNotebookByAttachedKernel: async (viewType: string, uri: URI) => {
+				return this.executeNotebookByAttachedKernel(viewType, uri);
+			},
+			cancelNotebookByAttachedKernel: async (viewType: string, uri: URI) => {
+				return this.cancelNotebookByAttachedKernel(viewType, uri);
+			},
+			onDidReceiveMessage: (editorId: string, rendererType: string | undefined, message: unknown) => {
+				this._proxy.$onDidReceiveMessage(editorId, rendererType, message);
+			},
+			removeNotebookDocument: async (uri: URI) => {
+				return this.removeNotebookTextModel(uri);
+			},
+			executeNotebookCell: async (uri: URI, handle: number) => {
+				return this._proxy.$executeNotebookByAttachedKernel(_viewType, uri, handle);
+			},
+			cancelNotebookCell: async (uri: URI, handle: number) => {
+				return this._proxy.$cancelNotebookByAttachedKernel(_viewType, uri, handle);
+			},
+			save: async (uri: URI, token: CancellationToken) => {
+				return this._proxy.$saveNotebook(_viewType, uri, token);
+			},
+			saveAs: async (uri: URI, target: URI, token: CancellationToken) => {
+				return this._proxy.$saveNotebookAs(_viewType, uri, target, token);
+			},
+			backup: async (uri: URI, token: CancellationToken) => {
+				return this._proxy.$backup(_viewType, uri, token);
+			}
+		};
+
+		this._notebookProviders.set(_viewType, controller);
+		this._notebookService.registerNotebookController(_viewType, _extension, controller);
 		return;
 	}

 	async $onNotebookChange(viewType: string, uri: UriComponents): Promise<void> {
-		let controller = this._notebookProviders.get(viewType);
-		if (controller) {
-			controller.handleNotebookChange(uri);
-		}
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(uri));
+		textModel?.handleUnknownChange();
 	}

 	async $unregisterNotebookProvider(viewType: string): Promise<void> {
@@ -462,16 +529,24 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 		const emitter = new Emitter<void>();
 		const that = this;
 		const provider = this._notebookService.registerNotebookKernelProvider({
+			providerExtensionId: extension.id.value,
+			providerDescription: extension.description,
 			onDidChangeKernels: emitter.event,
 			selector: documentFilter,
-			provideKernels: (uri: URI, token: CancellationToken) => {
-				return that._proxy.$provideNotebookKernels(handle, uri, token);
+			provideKernels: async (uri: URI, token: CancellationToken) => {
+				const kernels = await that._proxy.$provideNotebookKernels(handle, uri, token);
+				return kernels.map(kernel => {
+					return {
+						...kernel,
+						providerHandle: handle
+					};
+				});
 			},
 			resolveKernel: (editorId: string, uri: URI, kernelId: string, token: CancellationToken) => {
 				return that._proxy.$resolveNotebookKernel(handle, editorId, uri, kernelId, token);
 			},
-			executeNotebook: (uri: URI, kernelId: string, cellHandle: number | undefined, token: CancellationToken) => {
-				return that._proxy.$executeNotebookKernelFromProvider(handle, uri, kernelId, cellHandle, token);
+			executeNotebook: (uri: URI, kernelId: string, cellHandle: number | undefined) => {
+				return that._proxy.$executeNotebookKernelFromProvider(handle, uri, kernelId, cellHandle);
 			}
 		});
 		this._notebookKernelProviders.set(handle, {
@@ -500,36 +575,35 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 	}

 	async $updateNotebookLanguages(viewType: string, resource: UriComponents, languages: string[]): Promise<void> {
-		let controller = this._notebookProviders.get(viewType);
-
-		if (controller) {
-			controller.updateLanguages(resource, languages);
-		}
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+		textModel?.updateLanguages(languages);
 	}

 	async $updateNotebookMetadata(viewType: string, resource: UriComponents, metadata: NotebookDocumentMetadata): Promise<void> {
-		let controller = this._notebookProviders.get(viewType);
-
-		if (controller) {
-			controller.updateNotebookMetadata(resource, metadata);
-		}
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+		textModel?.updateNotebookMetadata(metadata);
 	}

 	async $updateNotebookCellMetadata(viewType: string, resource: UriComponents, handle: number, metadata: NotebookCellMetadata): Promise<void> {
-		let controller = this._notebookProviders.get(viewType);
-
-		if (controller) {
-			controller.updateNotebookCellMetadata(resource, handle, metadata);
-		}
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+		textModel?.updateNotebookCellMetadata(handle, metadata);
 	}

 	async $spliceNotebookCellOutputs(viewType: string, resource: UriComponents, cellHandle: number, splices: NotebookCellOutputsSplice[], renderers: number[]): Promise<void> {
-		let controller = this._notebookProviders.get(viewType);
-		await controller?.spliceNotebookCellOutputs(resource, cellHandle, splices, renderers);
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+
+		if (textModel) {
+			await this._notebookService.transformSpliceOutputs(textModel, splices);
+			textModel.$spliceNotebookCellOutputs(cellHandle, splices);
+		}
 	}

-	async executeNotebookByAttachedKernel(viewType: string, uri: URI, token: CancellationToken): Promise<void> {
-		return this._proxy.$executeNotebookByAttachedKernel(viewType, uri, undefined, token);
+	async executeNotebookByAttachedKernel(viewType: string, uri: URI): Promise<void> {
+		return this._proxy.$executeNotebookByAttachedKernel(viewType, uri, undefined);
+	}
+
+	async cancelNotebookByAttachedKernel(viewType: string, uri: URI): Promise<void> {
+		return this._proxy.$cancelNotebookByAttachedKernel(viewType, uri, undefined);
 	}

 	async $postMessage(editorId: string, forRendererId: string | undefined, value: any): Promise<boolean> {
@@ -543,220 +617,20 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 	}

 	$onDidEdit(resource: UriComponents, viewType: string, editId: number, label: string | undefined): void {
-		let controller = this._notebookProviders.get(viewType);
-		controller?.handleEdit(resource, editId, label);
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+
+		if (textModel) {
+			textModel.$handleEdit(label, () => {
+				return this._proxy.$undoNotebook(textModel.viewType, textModel.uri, editId, textModel.isDirty);
+			}, () => {
+				return this._proxy.$redoNotebook(textModel.viewType, textModel.uri, editId, textModel.isDirty);
+			});
+		}
 	}

 	$onContentChange(resource: UriComponents, viewType: string): void {
-		let controller = this._notebookProviders.get(viewType);
-		controller?.handleNotebookChange(resource);
-	}
-}
-
-export class MainThreadNotebookController implements IMainNotebookController {
-	private _mapping: Map<string, MainThreadNotebookDocument> = new Map();
-	static documentHandle: number = 0;
-
-	constructor(
-		private readonly _proxy: ExtHostNotebookShape,
-		private _mainThreadNotebook: MainThreadNotebooks,
-		private _viewType: string,
-		private _supportBackup: boolean,
-		readonly kernel: INotebookKernelInfoDto | undefined,
-		readonly notebookService: INotebookService,
-		readonly _instantiationService: IInstantiationService
-
-	) {
-	}
-
-	async createNotebook(viewType: string, uri: URI, backup: INotebookTextModelBackup | undefined, forceReload: boolean, editorId?: string, backupId?: string): Promise<NotebookTextModel | undefined> {
-		let mainthreadNotebook = this._mapping.get(URI.from(uri).toString());
-
-		if (mainthreadNotebook) {
-			if (forceReload) {
-				const data = await this._proxy.$resolveNotebookData(viewType, uri);
-				if (!data) {
-					return;
-				}
-
-				mainthreadNotebook.textModel.languages = data.languages;
-				mainthreadNotebook.textModel.metadata = data.metadata;
-				await mainthreadNotebook.applyEdit(mainthreadNotebook.textModel.versionId, [
-					{ editType: CellEditType.Delete, count: mainthreadNotebook.textModel.cells.length, index: 0 },
-					{ editType: CellEditType.Insert, index: 0, cells: data.cells }
-				], true, false);
-			}
-			return mainthreadNotebook.textModel;
-		}
-
-		let document = this._instantiationService.createInstance(MainThreadNotebookDocument, this._proxy, MainThreadNotebookController.documentHandle++, viewType, this._supportBackup, uri);
-		this._mapping.set(document.uri.toString(), document);
-
-		if (backup) {
-			// trigger events
-			document.textModel.metadata = backup.metadata;
-			document.textModel.languages = backup.languages;
-
-			// restored from backup, update the text model without emitting any event to exthost
-			await document.applyEdit(document.textModel.versionId, [
-				{
-					editType: CellEditType.Insert,
-					index: 0,
-					cells: backup.cells || []
-				}
-			], false, true);
-
-			// create document in ext host with cells data
-			await this._mainThreadNotebook.addNotebookDocument({
-				viewType: document.viewType,
-				handle: document.handle,
-				uri: document.uri,
-				metadata: document.textModel.metadata,
-				versionId: document.textModel.versionId,
-				cells: document.textModel.cells.map(cell => ({
-					handle: cell.handle,
-					uri: cell.uri,
-					source: cell.textBuffer.getLinesContent(),
-					eol: cell.textBuffer.getEOL(),
-					language: cell.language,
-					cellKind: cell.cellKind,
-					outputs: cell.outputs,
-					metadata: cell.metadata
-				})),
-				attachedEditor: editorId ? {
-					id: editorId,
-					selections: document.textModel.selections
-				} : undefined
-			});
-
-			return document.textModel;
-		}
-
-		// open notebook document
-		const data = await this._proxy.$resolveNotebookData(viewType, uri, backupId);
-		if (!data) {
-			return;
-		}
-
-		document.textModel.languages = data.languages;
-		document.textModel.metadata = data.metadata;
-
-		if (data.cells.length) {
-			document.textModel.initialize(data!.cells);
-		} else {
-			const mainCell = document.textModel.createCellTextModel([''], document.textModel.languages.length ? document.textModel.languages[0] : '', CellKind.Code, [], undefined);
-			document.textModel.insertTemplateCell(mainCell);
-		}
-
-		await this._mainThreadNotebook.addNotebookDocument({
-			viewType: document.viewType,
-			handle: document.handle,
-			uri: document.uri,
-			metadata: document.textModel.metadata,
-			versionId: document.textModel.versionId,
-			cells: document.textModel.cells.map(cell => ({
-				handle: cell.handle,
-				uri: cell.uri,
-				source: cell.textBuffer.getLinesContent(),
-				eol: cell.textBuffer.getEOL(),
-				language: cell.language,
-				cellKind: cell.cellKind,
-				outputs: cell.outputs,
-				metadata: cell.metadata
-			})),
-			attachedEditor: editorId ? {
-				id: editorId,
-				selections: document.textModel.selections
-			} : undefined
-		});
-
-		this._proxy.$acceptEditorPropertiesChanged(uri, { selections: null, metadata: document.textModel.metadata });
-
-		return document.textModel;
-	}
-
-	async resolveNotebookEditor(viewType: string, uri: URI, editorId: string) {
-		await this._proxy.$resolveNotebookEditor(viewType, uri, editorId);
-	}
-
-	async tryApplyEdits(resource: UriComponents, modelVersionId: number, edits: ICellEditOperation[], renderers: number[]): Promise<boolean> {
-		let mainthreadNotebook = this._mapping.get(URI.from(resource).toString());
-
-		if (mainthreadNotebook) {
-			return await mainthreadNotebook.applyEdit(modelVersionId, edits, true, true);
-		}
-
-		return false;
-	}
-
-	async spliceNotebookCellOutputs(resource: UriComponents, cellHandle: number, splices: NotebookCellOutputsSplice[], renderers: number[]): Promise<void> {
-		let mainthreadNotebook = this._mapping.get(URI.from(resource).toString());
-		await mainthreadNotebook?.spliceNotebookCellOutputs(cellHandle, splices);
-	}
-
-	async executeNotebookByAttachedKernel(viewType: string, uri: URI, token: CancellationToken): Promise<void> {
-		return this._mainThreadNotebook.executeNotebookByAttachedKernel(viewType, uri, token);
-	}
-
-	onDidReceiveMessage(editorId: string, rendererType: string | undefined, message: unknown): void {
-		this._proxy.$onDidReceiveMessage(editorId, rendererType, message);
-	}
-
-	async removeNotebookDocument(notebook: INotebookTextModel): Promise<void> {
-		let document = this._mapping.get(URI.from(notebook.uri).toString());
-
-		if (!document) {
-			return;
-		}
-
-		// TODO@rebornix, remove cell should use emitDelta as well to ensure document/editor events are sent together
-		await this._proxy.$acceptDocumentAndEditorsDelta({ removedDocuments: [notebook.uri] });
-		document.dispose();
-		this._mapping.delete(URI.from(notebook.uri).toString());
-	}
-
-	// Methods for ExtHost
-
-	handleNotebookChange(resource: UriComponents) {
-		let document = this._mapping.get(URI.from(resource).toString());
-		document?.textModel.handleUnknownChange();
-	}
-
-	handleEdit(resource: UriComponents, editId: number, label: string | undefined): void {
-		let document = this._mapping.get(URI.from(resource).toString());
-		document?.handleEdit(editId, label);
-	}
-
-	updateLanguages(resource: UriComponents, languages: string[]) {
-		let document = this._mapping.get(URI.from(resource).toString());
-		document?.textModel.updateLanguages(languages);
-	}
-
-	updateNotebookMetadata(resource: UriComponents, metadata: NotebookDocumentMetadata) {
-		let document = this._mapping.get(URI.from(resource).toString());
-		document?.textModel.updateNotebookMetadata(metadata);
-	}
-
-	updateNotebookCellMetadata(resource: UriComponents, handle: number, metadata: NotebookCellMetadata) {
-		let document = this._mapping.get(URI.from(resource).toString());
-		document?.textModel.updateNotebookCellMetadata(handle, metadata);
-	}
-
-	async executeNotebookCell(uri: URI, handle: number, token: CancellationToken): Promise<void> {
-		return this._proxy.$executeNotebookByAttachedKernel(this._viewType, uri, handle, token);
-	}
-
-	async save(uri: URI, token: CancellationToken): Promise<boolean> {
-		return this._proxy.$saveNotebook(this._viewType, uri, token);
-	}
-
-	async saveAs(uri: URI, target: URI, token: CancellationToken): Promise<boolean> {
-		return this._proxy.$saveNotebookAs(this._viewType, uri, target, token);
-	}
-
-	async backup(uri: URI, token: CancellationToken): Promise<string | undefined> {
-		const backupId = await this._proxy.$backup(this._viewType, uri, token);
-		return backupId;
+		const textModel = this._notebookService.getNotebookTextModel(URI.from(resource));
+		textModel?.handleUnknownChange();
 	}
 }

@@ -772,8 +646,8 @@ export class MainThreadNotebookKernel implements INotebookKernelInfo {
 	) {
 	}

-	async executeNotebook(viewType: string, uri: URI, handle: number | undefined, token: CancellationToken): Promise<void> {
-		return this._proxy.$executeNotebook2(this.id, viewType, uri, handle, token);
+	async executeNotebook(viewType: string, uri: URI, handle: number | undefined): Promise<void> {
+		return this._proxy.$executeNotebook2(this.id, viewType, uri, handle);
 	}
 }

--- a/src/vs/workbench/api/browser/mainThreadTask.ts
+++ b/src/vs/workbench/api/browser/mainThreadTask.ts
@@ -613,6 +613,9 @@ export class MainThreadTask implements MainThreadTaskShape {
 	public $registerTaskSystem(key: string, info: TaskSystemInfoDTO): void {
 		let platform: Platform.Platform;
 		switch (info.platform) {
+			case 'Web':
+				platform = Platform.Platform.Web;
+				break;
 			case 'win32':
 				platform = Platform.Platform.Windows;
 				break;
--- a/src/vs/workbench/api/common/extHost.api.impl.ts
+++ b/src/vs/workbench/api/common/extHost.api.impl.ts
@@ -933,10 +933,6 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 				checkProposedApiEnabled(extension);
 				return extHostNotebook.onDidChangeVisibleNotebookEditors;
 			},
-			get activeNotebookKernel() {
-				checkProposedApiEnabled(extension);
-				return extHostNotebook.activeNotebookKernel;
-			},
 			get onDidChangeActiveNotebookKernel() {
 				checkProposedApiEnabled(extension);
 				return extHostNotebook.onDidChangeActiveNotebookKernel;
@@ -1112,7 +1108,8 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			TimelineItem: extHostTypes.TimelineItem,
 			CellKind: extHostTypes.CellKind,
 			CellOutputKind: extHostTypes.CellOutputKind,
-			NotebookCellRunState: extHostTypes.NotebookCellRunState
+			NotebookCellRunState: extHostTypes.NotebookCellRunState,
+			NotebookRunState: extHostTypes.NotebookRunState
 		};
 	};
 }
--- a/src/vs/workbench/api/common/extHost.protocol.ts
+++ b/src/vs/workbench/api/common/extHost.protocol.ts
@@ -165,7 +165,7 @@ export interface MainThreadAuthenticationShape extends IDisposable {
 	$selectSession(providerId: string, providerName: string, extensionId: string, extensionName: string, potentialSessions: modes.AuthenticationSession[], scopes: string[], clearSessionPreference: boolean): Promise<modes.AuthenticationSession>;
 	$getSessionsPrompt(providerId: string, accountName: string, providerName: string, extensionId: string, extensionName: string): Promise<boolean>;
 	$loginPrompt(providerName: string, extensionName: string): Promise<boolean>;
-	$setTrustedExtension(providerId: string, accountName: string, extensionId: string, extensionName: string): Promise<void>;
+	$setTrustedExtensionAndAccountPreference(providerId: string, accountName: string, extensionId: string, extensionName: string, sessionId: string): Promise<void>;
 	$requestNewSession(providerId: string, scopes: string[], extensionId: string, extensionName: string): Promise<void>;

 	$getSessions(providerId: string): Promise<ReadonlyArray<modes.AuthenticationSession>>;
@@ -597,6 +597,7 @@ export interface WebviewExtensionDescription {
 export interface NotebookExtensionDescription {
 	readonly id: ExtensionIdentifier;
 	readonly location: UriComponents;
+	readonly description?: string;
 }

 export enum WebviewEditorCapabilities {
@@ -1616,13 +1617,15 @@ export interface ExtHostNotebookShape {
 	$resolveNotebookEditor(viewType: string, uri: UriComponents, editorId: string): Promise<void>;
 	$provideNotebookKernels(handle: number, uri: UriComponents, token: CancellationToken): Promise<INotebookKernelInfoDto2[]>;
 	$resolveNotebookKernel(handle: number, editorId: string, uri: UriComponents, kernelId: string, token: CancellationToken): Promise<void>;
-	$executeNotebookByAttachedKernel(viewType: string, uri: UriComponents, cellHandle: number | undefined, token: CancellationToken): Promise<void>;
-	$executeNotebookKernelFromProvider(handle: number, uri: UriComponents, kernelId: string, cellHandle: number | undefined, token: CancellationToken): Promise<void>;
-	$executeNotebook2(kernelId: string, viewType: string, uri: UriComponents, cellHandle: number | undefined, token: CancellationToken): Promise<void>;
+	$executeNotebookByAttachedKernel(viewType: string, uri: UriComponents, cellHandle: number | undefined): Promise<void>;
+	$cancelNotebookByAttachedKernel(viewType: string, uri: UriComponents, cellHandle: number | undefined): Promise<void>;
+	$executeNotebookKernelFromProvider(handle: number, uri: UriComponents, kernelId: string, cellHandle: number | undefined): Promise<void>;
+	$executeNotebook2(kernelId: string, viewType: string, uri: UriComponents, cellHandle: number | undefined): Promise<void>;
 	$saveNotebook(viewType: string, uri: UriComponents, token: CancellationToken): Promise<boolean>;
 	$saveNotebookAs(viewType: string, uri: UriComponents, target: UriComponents, token: CancellationToken): Promise<boolean>;
 	$backup(viewType: string, uri: UriComponents, cancellation: CancellationToken): Promise<string | undefined>;
 	$acceptDisplayOrder(displayOrder: INotebookDisplayOrder): void;
+	$acceptNotebookActiveKernelChange(event: { uri: UriComponents, providerHandle: number | undefined, kernelId: string | undefined }): void;
 	$renderOutputs(uriComponents: UriComponents, id: string, request: IOutputRenderRequest<UriComponents>): Promise<IOutputRenderResponse<UriComponents> | undefined>;
 	$renderOutputs2<T>(uriComponents: UriComponents, id: string, request: IOutputRenderRequest<T>): Promise<IOutputRenderResponse<T> | undefined>;
 	$onDidReceiveMessage(editorId: string, rendererId: string | undefined, message: unknown): void;
--- a/src/vs/workbench/api/common/extHostAuthentication.ts
+++ b/src/vs/workbench/api/common/extHostAuthentication.ts
@@ -37,7 +37,7 @@ export class ExtHostAuthentication implements ExtHostAuthenticationShape {
 	}

 	get providers(): ReadonlyArray<vscode.AuthenticationProviderInformation> {
-		return Object.freeze(this._providers);
+		return Object.freeze(this._providers.slice());
 	}

 	async getSession(requestingExtension: IExtensionDescription, providerId: string, scopes: string[], options: vscode.AuthenticationGetSessionOptions & { createIfNone: true }): Promise<vscode.AuthenticationSession>;
@@ -75,7 +75,7 @@ export class ExtHostAuthentication implements ExtHostAuthenticationShape {
 				}

 				const session = await provider.login(scopes);
-				await this._proxy.$setTrustedExtension(providerId, session.account.label, extensionId, extensionName);
+				await this._proxy.$setTrustedExtensionAndAccountPreference(providerId, session.account.label, extensionId, extensionName, session.id);
 				return session;
 			} else {
 				await this._proxy.$requestNewSession(providerId, scopes, extensionId, extensionName);
--- a/src/vs/workbench/api/common/extHostNotebook.ts
+++ b/src/vs/workbench/api/common/extHostNotebook.ts
@@ -16,7 +16,7 @@ import { ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
 import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
 import { CellEditType, diff, ICellEditOperation, ICellInsertEdit, INotebookDisplayOrder, INotebookEditData, NotebookCellsChangedEvent, NotebookCellsSplice2, ICellDeleteEdit, notebookDocumentMetadataDefaults, NotebookCellsChangeType, NotebookDataDto, IOutputRenderRequest, IOutputRenderResponse, IOutputRenderResponseOutputInfo, IOutputRenderResponseCellInfo, IRawOutput, CellOutputKind, IProcessedOutput, INotebookKernelInfoDto2, IMainCellDto } from 'vs/workbench/contrib/notebook/common/notebookCommon';
 import * as extHostTypes from 'vs/workbench/api/common/extHostTypes';
-import { CancellationToken } from 'vs/base/common/cancellation';
+import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
 import { ExtHostDocumentData } from 'vs/workbench/api/common/extHostDocumentData';
 import { NotImplementedProxy } from 'vs/base/common/types';
 import * as typeConverters from 'vs/workbench/api/common/extHostTypeConverters';
@@ -617,6 +617,16 @@ export class ExtHostNotebookEditor extends Disposable implements vscode.Notebook
 		this._active = value;
 	}

+	private _kernel?: vscode.NotebookKernel;
+
+	get kernel() {
+		return this._kernel;
+	}
+
+	set kernel(_kernel: vscode.NotebookKernel | undefined) {
+		throw readonly('kernel');
+	}
+
 	private _onDidDispose = new Emitter<void>();
 	readonly onDidDispose: Event<void> = this._onDidDispose.event;
 	private _onDidReceiveMessage = new Emitter<any>();
@@ -692,6 +702,9 @@ export class ExtHostNotebookEditor extends Disposable implements vscode.Notebook
 		throw readonly('viewColumn');
 	}

+	updateActiveKernel(kernel?: vscode.NotebookKernel) {
+		this._kernel = kernel;
+	}
 	async postMessage(message: any): Promise<boolean> {
 		return this._webComm.postMessage(message);
 	}
@@ -767,11 +780,18 @@ export class ExtHostNotebookKernelProviderAdapter extends Disposable {
 		const data = await this._provider.provideKernels(document, token) || [];

 		const newMap = new Map<vscode.NotebookKernel, string>();
+		let kernel_unique_pool = 0;
+		let kernelIdCache = new Set<string>();

 		const transformedData: INotebookKernelInfoDto2[] = data.map(kernel => {
 			let id = this._kernelToId.get(kernel);
 			if (id === undefined) {
-				id = UUID.generateUuid();
+				if (kernel.id && kernelIdCache.has(kernel.id)) {
+					id = `${this._extension.identifier.value}_${kernel.id}_${kernel_unique_pool++}`;
+				} else {
+					id = `${this._extension.identifier.value}_${kernel.id || UUID.generateUuid()}`;
+				}
+
 				this._kernelToId.set(kernel, id);
 			}

@@ -798,6 +818,10 @@ export class ExtHostNotebookKernelProviderAdapter extends Disposable {
 		return transformedData;
 	}

+	getKernel(kernelId: string) {
+		return this._idToKernel.get(kernelId);
+	}
+
 	async resolveNotebook(kernelId: string, document: ExtHostNotebookDocument, webview: vscode.NotebookCommunication, token: CancellationToken) {
 		const kernel = this._idToKernel.get(kernelId);

@@ -806,7 +830,7 @@ export class ExtHostNotebookKernelProviderAdapter extends Disposable {
 		}
 	}

-	async executeNotebook(kernelId: string, document: ExtHostNotebookDocument, cell: ExtHostCell | undefined, token: CancellationToken) {
+	async executeNotebook(kernelId: string, document: ExtHostNotebookDocument, cell: ExtHostCell | undefined) {
 		const kernel = this._idToKernel.get(kernelId);

 		if (!kernel) {
@@ -814,11 +838,35 @@ export class ExtHostNotebookKernelProviderAdapter extends Disposable {
 		}

 		if (cell) {
-			return kernel.executeCell(document, cell, token);
+			return withToken(token => (kernel.executeCell as any)(document, cell, token));
 		} else {
-			return kernel.executeAllCells(document, token);
+			return withToken(token => (kernel.executeAllCells as any)(document, token));
 		}
 	}
+
+	async cancelNotebook(kernelId: string, document: ExtHostNotebookDocument, cell: ExtHostCell | undefined) {
+		const kernel = this._idToKernel.get(kernelId);
+
+		if (!kernel) {
+			return;
+		}
+
+		if (cell) {
+			return kernel.cancelCellExecution(document, cell);
+		} else {
+			return kernel.cancelAllCellsExecution(document);
+		}
+	}
+}
+
+// TODO@roblou remove 'token' passed to all execute APIs once extensions are updated
+async function withToken(cb: (token: CancellationToken) => any) {
+	const source = new CancellationTokenSource();
+	try {
+		await cb(source.token);
+	} finally {
+		source.dispose();
+	}
 }

 export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostNotebookOutputRenderingHandler {
@@ -864,9 +912,7 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN
 	private _onDidCloseNotebookDocument = new Emitter<vscode.NotebookDocument>();
 	onDidCloseNotebookDocument: Event<vscode.NotebookDocument> = this._onDidCloseNotebookDocument.event;
 	visibleNotebookEditors: ExtHostNotebookEditor[] = [];
-	activeNotebookKernel?: vscode.NotebookKernel;
-
-	private _onDidChangeActiveNotebookKernel = new Emitter<void>();
+	private _onDidChangeActiveNotebookKernel = new Emitter<{ document: ExtHostNotebookDocument, kernel: vscode.NotebookKernel | undefined }>();
 	onDidChangeActiveNotebookKernel = this._onDidChangeActiveNotebookKernel.event;
 	private _onDidChangeVisibleNotebookEditors = new Emitter<vscode.NotebookEditor[]>();
 	onDidChangeVisibleNotebookEditors = this._onDidChangeVisibleNotebookEditors.event;
@@ -912,7 +958,7 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN

 		let extHostRenderer = new ExtHostNotebookOutputRenderer(type, filter, renderer);
 		this._notebookOutputRenderers.set(extHostRenderer.type, extHostRenderer);
-		this._proxy.$registerNotebookRenderer({ id: extension.identifier, location: extension.extensionLocation }, type, filter, renderer.preloads || []);
+		this._proxy.$registerNotebookRenderer({ id: extension.identifier, location: extension.extensionLocation, description: extension.description }, type, filter, renderer.preloads || []);
 		return new extHostTypes.Disposable(() => {
 			this._notebookOutputRenderers.delete(extHostRenderer.type);
 			this._proxy.$unregisterNotebookRenderer(extHostRenderer.type);
@@ -1037,7 +1083,7 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN

 		const supportBackup = !!provider.backupNotebook;

-		this._proxy.$registerNotebookProvider({ id: extension.identifier, location: extension.extensionLocation }, viewType, supportBackup, provider.kernel ? { id: viewType, label: provider.kernel.label, extensionLocation: extension.extensionLocation, preloads: provider.kernel.preloads } : undefined);
+		this._proxy.$registerNotebookProvider({ id: extension.identifier, location: extension.extensionLocation, description: extension.description }, viewType, supportBackup, provider.kernel ? { id: viewType, label: provider.kernel.label, extensionLocation: extension.extensionLocation, preloads: provider.kernel.preloads } : undefined);

 		return new extHostTypes.Disposable(() => {
 			listener.dispose();
@@ -1050,7 +1096,7 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN
 		const handle = ExtHostNotebookController._notebookKernelProviderHandlePool++;
 		const adapter = new ExtHostNotebookKernelProviderAdapter(this._proxy, handle, extension, provider);
 		this._notebookKernelProviders.set(handle, adapter);
-		this._proxy.$registerNotebookKernelProvider({ id: extension.identifier, location: extension.extensionLocation }, handle, {
+		this._proxy.$registerNotebookKernelProvider({ id: extension.identifier, location: extension.extensionLocation, description: extension.description }, handle, {
 			viewType: selector.viewType,
 			filenamePattern: selector.filenamePattern ? typeConverters.GlobPattern.from(selector.filenamePattern) : undefined,
 			excludeFileNamePattern: selector.excludeFileNamePattern ? typeConverters.GlobPattern.from(selector.excludeFileNamePattern) : undefined,
@@ -1103,7 +1149,7 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN
 		this._notebookKernels.set(id, { kernel, extension });
 		const transformedSelectors = selectors.map(selector => typeConverters.GlobPattern.from(selector));

-		this._proxy.$registerNotebookKernel({ id: extension.identifier, location: extension.extensionLocation }, id, kernel.label, transformedSelectors, kernel.preloads || []);
+		this._proxy.$registerNotebookKernel({ id: extension.identifier, location: extension.extensionLocation, description: extension.description }, id, kernel.label, transformedSelectors, kernel.preloads || []);
 		return new extHostTypes.Disposable(() => {
 			this._notebookKernels.delete(id);
 			this._proxy.$unregisterNotebookKernel(id);
@@ -1198,7 +1244,7 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN
 		}
 	}

-	async $executeNotebookByAttachedKernel(viewType: string, uri: UriComponents, cellHandle: number | undefined, token: CancellationToken): Promise<void> {
+	async $executeNotebookByAttachedKernel(viewType: string, uri: UriComponents, cellHandle: number | undefined): Promise<void> {
 		let document = this._documents.get(URI.revive(uri).toString());

 		if (!document) {
@@ -1211,23 +1257,44 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN

 			if (provider.kernel) {
 				if (cell) {
-					return provider.kernel.executeCell(document, cell, token);
+					return withToken(token => (provider.kernel!.executeCell as any)(document, cell, token));
 				} else {
-					return provider.kernel.executeAllCells(document, token);
+					return withToken(token => (provider.kernel!.executeAllCells as any)(document, token));
 				}
 			}
 		}
 	}

-	async $executeNotebookKernelFromProvider(handle: number, uri: UriComponents, kernelId: string, cellHandle: number | undefined, token: CancellationToken): Promise<void> {
+	async $cancelNotebookByAttachedKernel(viewType: string, uri: UriComponents, cellHandle: number | undefined): Promise<void> {
+		const document = this._documents.get(URI.revive(uri).toString());
+
+		if (!document) {
+			return;
+		}
+
+		if (this._notebookContentProviders.has(viewType)) {
+			const cell = cellHandle !== undefined ? document.getCell(cellHandle) : undefined;
+			const provider = this._notebookContentProviders.get(viewType)!.provider;
+
+			if (provider.kernel) {
+				if (cell) {
+					return provider.kernel.cancelCellExecution(document, cell);
+				} else {
+					return provider.kernel.cancelAllCellsExecution(document);
+				}
+			}
+		}
+	}
+
+	async $executeNotebookKernelFromProvider(handle: number, uri: UriComponents, kernelId: string, cellHandle: number | undefined): Promise<void> {
 		await this._withAdapter(handle, uri, async (adapter, document) => {
 			let cell = cellHandle !== undefined ? document.getCell(cellHandle) : undefined;

-			return adapter.executeNotebook(kernelId, document, cell, token);
+			return adapter.executeNotebook(kernelId, document, cell);
 		});
 	}

-	async $executeNotebook2(kernelId: string, viewType: string, uri: UriComponents, cellHandle: number | undefined, token: CancellationToken): Promise<void> {
+	async $executeNotebook2(kernelId: string, viewType: string, uri: UriComponents, cellHandle: number | undefined): Promise<void> {
 		let document = this._documents.get(URI.revive(uri).toString());

 		if (!document || document.viewType !== viewType) {
@@ -1243,9 +1310,9 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN
 		let cell = cellHandle !== undefined ? document.getCell(cellHandle) : undefined;

 		if (cell) {
-			return kernelInfo.kernel.executeCell(document, cell, token);
+			return withToken(token => (kernelInfo!.kernel.executeCell as any)(document, cell, token));
 		} else {
-			return kernelInfo.kernel.executeAllCells(document, token);
+			return withToken(token => (kernelInfo!.kernel.executeAllCells as any)(document, token));
 		}
 	}

@@ -1314,6 +1381,20 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN
 		this._outputDisplayOrder = displayOrder;
 	}

+	$acceptNotebookActiveKernelChange(event: { uri: UriComponents, providerHandle: number | undefined, kernelId: string | undefined }) {
+		if (event.providerHandle !== undefined) {
+			this._withAdapter(event.providerHandle, event.uri, async (adapter, document) => {
+				const kernel = event.kernelId ? adapter.getKernel(event.kernelId) : undefined;
+				this._editors.forEach(editor => {
+					if (editor.editor.document === document) {
+						editor.editor.updateActiveKernel(kernel);
+					}
+				});
+				this._onDidChangeActiveNotebookKernel.fire({ document, kernel });
+			});
+		}
+	}
+
 	// TODO: remove document - editor one on one mapping
 	private _getEditorFromURI(uriComponents: UriComponents) {
 		const uriStr = URI.revive(uriComponents).toString();
--- a/src/vs/workbench/api/common/extHostTask.ts
+++ b/src/vs/workbench/api/common/extHostTask.ts
@@ -696,13 +696,11 @@ export class WorkerExtHostTask extends ExtHostTaskBase {
 		@IExtHostApiDeprecationService deprecationService: IExtHostApiDeprecationService
 	) {
 		super(extHostRpc, initData, workspaceService, editorService, configurationService, extHostTerminalService, logService, deprecationService);
-		if (initData.remote.isRemote && initData.remote.authority) {
-			this.registerTaskSystem(Schemas.vscodeRemote, {
-				scheme: Schemas.vscodeRemote,
-				authority: initData.remote.authority,
-				platform: Platform.PlatformToString(Platform.Platform.Web)
-			});
-		}
+		this.registerTaskSystem(Schemas.vscodeRemote, {
+			scheme: Schemas.vscodeRemote,
+			authority: '',
+			platform: Platform.PlatformToString(Platform.Platform.Web)
+		});
 	}

 	public async executeTask(extension: IExtensionDescription, task: vscode.Task): Promise<vscode.TaskExecution> {
--- a/src/vs/workbench/api/common/extHostTypes.ts
+++ b/src/vs/workbench/api/common/extHostTypes.ts
@@ -2739,6 +2739,11 @@ export enum NotebookCellRunState {
 	Error = 4
 }

+export enum NotebookRunState {
+	Running = 1,
+	Idle = 2
+}
+
 //#endregion

 //#region Timeline
--- a/src/vs/workbench/api/common/menusExtensionPoint.ts
+++ b/src/vs/workbench/api/common/menusExtensionPoint.ts
@@ -51,7 +51,7 @@ namespace schema {
 			case 'menuBar/webNavigation': return MenuId.MenubarWebNavigationMenu;
 			case 'scm/title': return MenuId.SCMTitle;
 			case 'scm/sourceControl': return MenuId.SCMSourceControl;
-			case 'scm/resourceState/context': return MenuId.SCMResourceContext;//
+			case 'scm/resourceState/context': return MenuId.SCMResourceContext;
 			case 'scm/resourceFolder/context': return MenuId.SCMResourceFolderContext;
 			case 'scm/resourceGroup/context': return MenuId.SCMResourceGroupContext;
 			case 'scm/change/title': return MenuId.SCMChangeContext;//