Moving away from execCommand for pasting (#239233)

* adding code to invetsigate the clipboard

* adding more code

* adding change

* adding logs

* adding notes

* making deubgging easier

* adding code to fix paste

* adding code to allow await before trigger paste

* removing all logs

* removing log

* refactoring

* removing change

* adding fix after call

* polishing

* fixing merge conflict

* polishing

Author: aiday-mar

src/vs/editor/browser/controller/editContext/native/nativeEditContext.ts

@@ -30,6 +30,7 @@ import { EditContext } from './editContextFactory.js';
 import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.js';
 import { NativeEditContextRegistry } from './nativeEditContextRegistry.js';
 import { IEditorAriaOptions } from '../../../editorBrowser.js';
+import { IClipboardService } from '../../../../../platform/clipboard/common/clipboardService.js';
 
 // Corresponds to classes in nativeEditContext.css
 enum CompositionClassName {
@@ -68,7 +69,8 @@ export class NativeEditContext extends AbstractEditContext {
 		viewController: ViewController,
 		private readonly _visibleRangeProvider: IVisibleRangeProvider,
 		@IInstantiationService instantiationService: IInstantiationService,
-		@IAccessibilityService private readonly _accessibilityService: IAccessibilityService
+		@IAccessibilityService private readonly _accessibilityService: IAccessibilityService,
+		@IClipboardService private readonly _clipboardService: IClipboardService,
 	) {
 		super(context);
 
@@ -253,24 +255,26 @@ export class NativeEditContext extends AbstractEditContext {
 		return true;
 	}
 
-	public executePaste(): boolean {
+	public triggerPaste(): Promise<void> | undefined {
 		this._onWillPaste();
-		try {
-			// pause focus tracking because we don't want to react to focus/blur
-			// events while pasting since we move the focus to the textarea
-			this._focusTracker.pause();
-
-			// Since we can not call execCommand('paste') on a dom node with edit context set
-			// we added a hidden text area that receives the paste execution
-			this._textArea.focus();
-			const result = this._textArea.domNode.ownerDocument.execCommand('paste');
-			this._textArea.domNode.textContent = '';
-			this.domNode.focus();
-
-			return result;
-		} finally {
+		// pause focus tracking because we don't want to react to focus/blur
+		// events while pasting since we move the focus to the textarea
+		this._focusTracker.pause();
+
+		// Since we can not call execCommand('paste') on a dom node with edit context set
+		// we added a hidden text area that receives the paste execution
+		this._textArea.focus();
+		const triggerPaste = this._clipboardService.triggerPaste();
+		if (!triggerPaste) {
+			this.domNode.domNode.focus();
 			this._focusTracker.resume(); // resume focus tracking
+			return undefined;
 		}
+		return triggerPaste.then(() => {
+			this._textArea.domNode.textContent = '';
+			this.domNode.domNode.focus();
+			this._focusTracker.resume(); // resume focus tracking
+		});
 	}
 
 	private _onWillPaste(): void {

src/vs/editor/contrib/clipboard/browser/clipboard.ts

@@ -234,21 +234,26 @@ if (PasteAction) {
 		const focusedEditor = codeEditorService.getFocusedCodeEditor();
 		if (focusedEditor && focusedEditor.hasModel() && focusedEditor.hasTextFocus()) {
 			// execCommand(paste) does not work with edit context
-			let result: boolean;
 			const experimentalEditContextEnabled = focusedEditor.getOption(EditorOption.effectiveExperimentalEditContextEnabled);
 			if (experimentalEditContextEnabled) {
 				const nativeEditContext = NativeEditContextRegistry.get(focusedEditor.getId());
 				if (nativeEditContext) {
-					result = nativeEditContext.executePaste();
-				} else {
-					result = false;
+					const triggerPaste = nativeEditContext.triggerPaste();
+					if (triggerPaste) {
+						return triggerPaste.then(async () => {
+							return CopyPasteController.get(focusedEditor)?.finishedPaste() ?? Promise.resolve();
+						});
+					}
 				}
 			} else {
-				result = focusedEditor.getContainerDomNode().ownerDocument.execCommand('paste');
+				const triggerPaste = clipboardService.triggerPaste();
+				if (triggerPaste) {
+					return triggerPaste.then(async () => {
+						return CopyPasteController.get(focusedEditor)?.finishedPaste() ?? Promise.resolve();
+					});
+				}
 			}
-			if (result) {
-				return CopyPasteController.get(focusedEditor)?.finishedPaste() ?? Promise.resolve();
-			} else if (platform.isWeb) {
+			if (platform.isWeb) {
 				// Use the clipboard service if document.execCommand('paste') was not successful
 				return (async () => {
 					const clipboardText = await clipboardService.readText();
@@ -278,8 +283,8 @@ if (PasteAction) {
 
 	// 2. Paste: (default) handle case when focus is somewhere else.
 	PasteAction.addImplementation(0, 'generic-dom', (accessor: ServicesAccessor, args: any) => {
-		getActiveDocument().execCommand('paste');
-		return true;
+		const triggerPaste = accessor.get(IClipboardService).triggerPaste();
+		return triggerPaste ?? false;
 	});
 }
 

src/vs/platform/clipboard/browser/clipboardService.ts

@@ -45,6 +45,10 @@ export class BrowserClipboardService extends Disposable implements IClipboardSer
 		}, { window: mainWindow, disposables: this._store }));
 	}
 
+	triggerPaste(): Promise<void> | undefined {
+		return undefined;
+	}
+
 	async readImage(): Promise<Uint8Array> {
 		try {
 			const clipboardItems = await navigator.clipboard.read();

src/vs/platform/clipboard/common/clipboardService.ts

@@ -12,6 +12,11 @@ export interface IClipboardService {
 
 	readonly _serviceBrand: undefined;
 
+	/**
+	 * Trigger the paste. Returns undefined if the paste was not triggered or a promise that resolves on paste end.
+	 */
+	triggerPaste(): Promise<void> | undefined;
+
 	/**
 	 * Writes text to the system clipboard.
 	 */

src/vs/platform/clipboard/test/common/testClipboardService.ts

@@ -15,6 +15,10 @@ export class TestClipboardService implements IClipboardService {
 
 	private text: string | undefined = undefined;
 
+	triggerPaste(): Promise<void> | undefined {
+		return Promise.resolve();
+	}
+
 	async writeText(text: string, type?: string): Promise<void> {
 		this.text = text;
 	}

src/vs/platform/native/common/native.ts

@@ -150,6 +150,7 @@ export interface ICommonNativeHostService {
 	killProcess(pid: number, code: string): Promise<void>;
 
 	// Clipboard
+	triggerPaste(): Promise<void>;
 	readClipboardText(type?: 'selection' | 'clipboard'): Promise<string>;
 	writeClipboardText(text: string, type?: 'selection' | 'clipboard'): Promise<void>;
 	readClipboardFindText(): Promise<string>;

src/vs/platform/native/electron-main/nativeHostMainService.ts

@@ -751,6 +751,11 @@ export class NativeHostMainService extends Disposable implements INativeHostMain
 		return clipboard.readText(type);
 	}
 
+	async triggerPaste(windowId: number | undefined): Promise<void> {
+		const window = this.windowById(windowId);
+		return window?.win?.webContents.paste() ?? Promise.resolve();
+	}
+
 	async readImage(): Promise<Uint8Array> {
 		return clipboard.readImage().toPNG();
 	}

src/vs/workbench/services/clipboard/electron-sandbox/clipboardService.ts

@@ -20,6 +20,10 @@ export class NativeClipboardService implements IClipboardService {
 		@INativeHostService private readonly nativeHostService: INativeHostService
 	) { }
 
+	async triggerPaste(): Promise<void> {
+		return this.nativeHostService.triggerPaste();
+	}
+
 	async readImage(): Promise<Uint8Array> {
 		return this.nativeHostService.readImage();
 	}

src/vs/workbench/test/electron-sandbox/workbenchTestServices.ts

@@ -156,6 +156,7 @@ export class TestNativeHostService implements INativeHostService {
 	async readClipboardFindText(): Promise<string> { return ''; }
 	async writeClipboardFindText(text: string): Promise<void> { }
 	async writeClipboardBuffer(format: string, buffer: VSBuffer, type?: 'selection' | 'clipboard' | undefined): Promise<void> { }
+	async triggerPaste(): Promise<void> { }
 	async readImage(): Promise<Uint8Array> { return Uint8Array.from([]); }
 	async readClipboardBuffer(format: string): Promise<VSBuffer> { return VSBuffer.wrap(Uint8Array.from([])); }
 	async hasClipboard(format: string, type?: 'selection' | 'clipboard' | undefined): Promise<boolean> { return false; }