Implement CancellationToken logic for withProgress API

packages/plugin-ext/src/common/plugin-api-rpc.ts

@@ -762,6 +762,7 @@ export interface NotificationExt {
         options: ProgressOptions,
         task: (progress: Progress<{ message?: string; increment?: number }>, token: CancellationToken) => PromiseLike<R>
     ): PromiseLike<R>;
+    $acceptProgressCanceled(progressId: string): void;
 }
 
 export interface ScmCommandArg {
@@ -1812,6 +1813,7 @@ export const PLUGIN_RPC_CONTEXT = {
     STATUS_BAR_MESSAGE_REGISTRY_MAIN: <ProxyIdentifier<StatusBarMessageRegistryMain>>createProxyIdentifier<StatusBarMessageRegistryMain>('StatusBarMessageRegistryMain'),
     ENV_MAIN: createProxyIdentifier<EnvMain>('EnvMain'),
     NOTIFICATION_MAIN: createProxyIdentifier<NotificationMain>('NotificationMain'),
+    NOTIFICATION_EXT: createProxyIdentifier<NotificationExt>('NotificationExt'),
     TERMINAL_MAIN: createProxyIdentifier<TerminalServiceMain>('TerminalServiceMain'),
     TREE_VIEWS_MAIN: createProxyIdentifier<TreeViewsMain>('TreeViewsMain'),
     PREFERENCE_REGISTRY_MAIN: createProxyIdentifier<PreferenceRegistryMain>('PreferenceRegistryMain'),
@@ -1843,6 +1845,7 @@ export const MAIN_RPC_CONTEXT = {
     QUICK_OPEN_EXT: createProxyIdentifier<QuickOpenExt>('QuickOpenExt'),
     WINDOW_STATE_EXT: createProxyIdentifier<WindowStateExt>('WindowStateExt'),
     NOTIFICATION_EXT: createProxyIdentifier<NotificationExt>('NotificationExt'),
+    NOTIFICATION_MAIN: createProxyIdentifier<NotificationMain>('NotificationMain'),
     WORKSPACE_EXT: createProxyIdentifier<WorkspaceExt>('WorkspaceExt'),
     TEXT_EDITORS_EXT: createProxyIdentifier<TextEditorsExt>('TextEditorsExt'),
     EDITORS_AND_DOCUMENTS_EXT: createProxyIdentifier<EditorsAndDocumentsExt>('EditorsAndDocumentsExt'),

packages/plugin-ext/src/main/browser/main-context.ts

@@ -57,6 +57,7 @@ import { CustomEditorsMainImpl } from './custom-editors/custom-editors-main';
 import { SecretsMainImpl } from './secrets-main';
 import { WebviewViewsMainImpl } from './webview-views/webview-views-main';
 import { MonacoLanguages } from '@theia/monaco/lib/browser/monaco-languages';
+import { NotificationExtImpl } from '../../plugin/notification';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const authenticationMain = new AuthenticationMainImpl(rpc, container);
@@ -108,6 +109,9 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
     const notificationMain = new NotificationMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.NOTIFICATION_MAIN, notificationMain);
 
+    const notificationExt = new NotificationExtImpl(rpc);
+    rpc.set(MAIN_RPC_CONTEXT.NOTIFICATION_EXT, notificationExt);
+
     const terminalMain = new TerminalServiceMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.TERMINAL_MAIN, terminalMain);
 

packages/plugin-ext/src/main/browser/notification-main.ts

@@ -14,33 +14,41 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { NotificationMain } from '../../common/plugin-api-rpc';
+import { NotificationExt, NotificationMain, MAIN_RPC_CONTEXT } from '../../common';
 import { ProgressService, Progress, ProgressMessage } from '@theia/core/lib/common';
 import { interfaces } from '@theia/core/shared/inversify';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 
 export class NotificationMainImpl implements NotificationMain, Disposable {
-
     private readonly progressService: ProgressService;
     private readonly progressMap = new Map<string, Progress>();
     private readonly progress2Work = new Map<string, number>();
+    private readonly proxy: NotificationExt;
 
     protected readonly toDispose = new DisposableCollection(
         Disposable.create(() => { /* mark as not disposed */ })
     );
 
     constructor(rpc: RPCProtocol, container: interfaces.Container) {
         this.progressService = container.get(ProgressService);
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.NOTIFICATION_EXT);
     }
 
     dispose(): void {
         this.toDispose.dispose();
     }
 
     async $startProgress(options: NotificationMain.StartProgressOptions): Promise<string> {
+        const onDidCancel = () => {
+            // If the map does not contain current id, it has already stopped and should not be cancelled
+            if (this.progressMap.has(id)) {
+                this.proxy.$acceptProgressCanceled(id);
+            }
+        };
+
         const progressMessage = this.mapOptions(options);
-        const progress = await this.progressService.showProgress(progressMessage);
+        const progress = await this.progressService.showProgress(progressMessage, onDidCancel);
         const id = progress.id;
         this.progressMap.set(id, progress);
         this.progress2Work.set(id, 0);
@@ -58,10 +66,11 @@ export class NotificationMainImpl implements NotificationMain, Disposable {
 
     $stopProgress(id: string): void {
         const progress = this.progressMap.get(id);
+
         if (progress) {
-            progress.cancel();
             this.progressMap.delete(id);
             this.progress2Work.delete(id);
+            progress.cancel();
         }
     }
 

packages/plugin-ext/src/plugin/notification.ts

@@ -23,6 +23,7 @@ import { Deferred } from '@theia/core/lib/common/promise-util';
 
 export class NotificationExtImpl implements NotificationExt {
     private readonly proxy: NotificationMain;
+    private mapProgressIdToCancellationSource: Map<string, CancellationTokenSource> = new Map();
 
     constructor(rpc: RPCProtocol) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.NOTIFICATION_MAIN);
@@ -32,13 +33,20 @@ export class NotificationExtImpl implements NotificationExt {
         options: ProgressOptions,
         task: (progress: Progress<{ message?: string; increment?: number }>, token: CancellationToken) => PromiseLike<R>
     ): Promise<R> {
+        const source = new CancellationTokenSource();
         const id = new Deferred<string>();
-        const tokenSource = new CancellationTokenSource();
-        const progress = task({ report: async item => this.proxy.$updateProgress(await id.promise, item)}, tokenSource.token);
+        const progress = task({ report: async item => this.proxy.$updateProgress(await id.promise, item)}, source.token);
         const title = options.title ? options.title : '';
         const location = this.mapLocation(options.location);
         const cancellable = options.cancellable;
+
         id.resolve(await this.proxy.$startProgress({ title, location, cancellable }));
+
+        if (cancellable) {
+            const progressId = await id.promise;
+            this.mapProgressIdToCancellationSource.set(progressId, source);
+        }
+
         const stop = async () => this.proxy.$stopProgress(await id.promise);
         const promise = Promise.all([
             progress,
@@ -48,6 +56,14 @@ export class NotificationExtImpl implements NotificationExt {
         return progress;
     }
 
+    public $acceptProgressCanceled(id: string): void {
+        const source = this.mapProgressIdToCancellationSource.get(id);
+        if (source) {
+            source.cancel();
+            this.mapProgressIdToCancellationSource.delete(id);
+        }
+    }
+
     protected mapLocation(location: ProgressLocation | { viewId: string }): string | undefined {
         if (typeof location === 'object') {
             return location.viewId;