VS Code merge to df8fe74bd55313de0dd2303bc47a4aab0ca56b0e (#17979)

* Merge from vscode 504f934659740e9d41501cad9f162b54d7745ad9

* delete unused folders

* distro

* Bump build node version

* update chokidar

* FIx hygiene errors

* distro

* Fix extension lint issues

* Remove strict-vscode

* Add copyright header exemptions

* Bump vscode-extension-telemetry to fix webpacking issue with zone.js

* distro

* Fix failing tests (revert marked.js back to current one until we decide to update)

* Skip searchmodel test

* Fix mac build

* temp debug script loading

* Try disabling coverage

* log error too

* Revert "log error too"

This reverts commit af0183e5d4ab458fdf44b88fbfab9908d090526f.

* Revert "temp debug script loading"

This reverts commit 3d687d541c76db2c5b55626c78ae448d3c25089c.

* Add comments explaining coverage disabling

* Fix ansi_up loading issue

* Merge latest from ads

* Use newer option

* Fix compile

* add debug logging warn

* Always log stack

* log more

* undo debug

* Update to use correct base path (+cleanup)

* distro

* fix compile errors

* Remove strict-vscode

* Fix sql editors not showing

* Show db dropdown input & fix styling

* Fix more info in gallery

* Fix gallery asset requests

* Delete unused workflow

* Fix tapable resolutions for smoke test compile error

* Fix smoke compile

* Disable crash reporting

* Disable interactive

Co-authored-by: ADS Merger <karlb@microsoft.com>

src/vs/platform/webview/common/mimeTypes.ts

@@ -3,13 +3,13 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { getMediaMime, MIME_UNKNOWN } from 'vs/base/common/mime';
+import { getMediaMime, Mimes } from 'vs/base/common/mime';
 import { extname } from 'vs/base/common/path';
 import { URI } from 'vs/base/common/uri';
 
 const webviewMimeTypes = new Map([
 	['.svg', 'image/svg+xml'],
-	['.txt', 'text/plain'],
+	['.txt', Mimes.text],
 	['.css', 'text/css'],
 	['.js', 'application/javascript'],
 	['.json', 'application/json'],
@@ -18,9 +18,10 @@ const webviewMimeTypes = new Map([
 	['.xhtml', 'application/xhtml+xml'],
 	['.oft', 'font/otf'],
 	['.xml', 'application/xml'],
+	['.wasm', 'application/wasm'],
 ]);
 
 export function getWebviewContentMimeType(resource: URI): string {
 	const ext = extname(resource.fsPath).toLowerCase();
-	return webviewMimeTypes.get(ext) || getMediaMime(resource.fsPath) || MIME_UNKNOWN;
+	return webviewMimeTypes.get(ext) || getMediaMime(resource.fsPath) || Mimes.unknown;
 }

src/vs/platform/webview/common/webviewManagerService.ts

@@ -3,12 +3,11 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { Event } from 'vs/base/common/event';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 
 export const IWebviewManagerService = createDecorator<IWebviewManagerService>('webviewManagerService');
 
-export const webviewPartitionId = 'webview';
-
 export interface WebviewWebContentsId {
 	readonly webContentsId: number;
 }
@@ -17,8 +16,28 @@ export interface WebviewWindowId {
 	readonly windowId: number;
 }
 
+export interface FindInFrameOptions {
+	forward?: boolean;
+	findNext?: boolean;
+	matchCase?: boolean;
+}
+
+export interface FoundInFrameResult {
+	requestId: number;
+	activeMatchOrdinal: number;
+	matches: number;
+	selectionArea: any;
+	finalUpdate: boolean;
+}
+
 export interface IWebviewManagerService {
 	_serviceBrand: unknown;
 
+	onFoundInFrame: Event<FoundInFrameResult>;
+
 	setIgnoreMenuShortcuts(id: WebviewWebContentsId | WebviewWindowId, enabled: boolean): Promise<void>;
+
+	findInFrame(windowId: WebviewWindowId, frameName: string, text: string, options: FindInFrameOptions): Promise<void>;
+
+	stopFindInFrame(windowId: WebviewWindowId, frameName: string, options: { keepSelection?: boolean }): Promise<void>;
 }

src/vs/platform/webview/electron-main/webviewMainService.ts

@@ -3,10 +3,10 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { session, WebContents, webContents } from 'electron';
+import { WebContents, webContents, WebFrameMain } from 'electron';
+import { Emitter } from 'vs/base/common/event';
 import { Disposable } from 'vs/base/common/lifecycle';
-import { ITunnelService } from 'vs/platform/remote/common/tunnel';
-import { IWebviewManagerService, webviewPartitionId, WebviewWebContentsId, WebviewWindowId } from 'vs/platform/webview/common/webviewManagerService';
+import { FindInFrameOptions, FoundInFrameResult, IWebviewManagerService, WebviewWebContentsId, WebviewWindowId } from 'vs/platform/webview/common/webviewManagerService';
 import { WebviewProtocolProvider } from 'vs/platform/webview/electron-main/webviewProtocolProvider';
 import { IWindowsMainService } from 'vs/platform/windows/electron-main/windows';
 
@@ -14,25 +14,14 @@ export class WebviewMainService extends Disposable implements IWebviewManagerSer
 
 	declare readonly _serviceBrand: undefined;
 
+	private readonly _onFoundInFrame = this._register(new Emitter<FoundInFrameResult>());
+	public onFoundInFrame = this._onFoundInFrame.event;
+
 	constructor(
-		@ITunnelService tunnelService: ITunnelService,
 		@IWindowsMainService private readonly windowsMainService: IWindowsMainService,
 	) {
 		super();
 		this._register(new WebviewProtocolProvider());
-
-		const sess = session.fromPartition(webviewPartitionId);
-		sess.setPermissionRequestHandler((_webContents, permission, callback) => {
-			if (permission === 'clipboard-read') {
-				return callback(true);
-			}
-
-			return callback(false);
-		});
-
-		sess.setPermissionCheckHandler((_webContents, permission /* 'media' */) => {
-			return permission === 'clipboard-read';
-		});
 	}
 
 	public async setIgnoreMenuShortcuts(id: WebviewWebContentsId | WebviewWindowId, enabled: boolean): Promise<void> {
@@ -57,4 +46,53 @@ export class WebviewMainService extends Disposable implements IWebviewManagerSer
 			contents.setIgnoreMenuShortcuts(enabled);
 		}
 	}
+
+	public async findInFrame(windowId: WebviewWindowId, frameName: string, text: string, options: { findNext?: boolean, forward?: boolean }): Promise<void> {
+		const initialFrame = this.getFrameByName(windowId, frameName);
+
+		type WebFrameMainWithFindSupport = typeof WebFrameMain & {
+			findInFrame?(text: string, findOptions: FindInFrameOptions): void;
+		};
+		const frame = initialFrame as unknown as WebFrameMainWithFindSupport;
+		if (typeof frame.findInFrame === 'function') {
+			frame.findInFrame(text, {
+				findNext: options.findNext,
+				forward: options.forward,
+			});
+			const foundInFrameHandler = (_: unknown, result: FoundInFrameResult) => {
+				if (result.finalUpdate) {
+					this._onFoundInFrame.fire(result);
+					initialFrame.removeListener('found-in-frame', foundInFrameHandler);
+				}
+			};
+			initialFrame.on('found-in-frame', foundInFrameHandler);
+		}
+	}
+
+	public async stopFindInFrame(windowId: WebviewWindowId, frameName: string, options: { keepSelection?: boolean }): Promise<void> {
+		const initialFrame = this.getFrameByName(windowId, frameName);
+
+		type WebFrameMainWithFindSupport = typeof WebFrameMain & {
+			stopFindInFrame?(stopOption: 'keepSelection' | 'clearSelection'): void;
+		};
+
+		const frame = initialFrame as unknown as WebFrameMainWithFindSupport;
+		if (typeof frame.stopFindInFrame === 'function') {
+			frame.stopFindInFrame(options.keepSelection ? 'keepSelection' : 'clearSelection');
+		}
+	}
+
+	private getFrameByName(windowId: WebviewWindowId, frameName: string): WebFrameMain {
+		const window = this.windowsMainService.getWindowById(windowId.windowId);
+		if (!window?.win) {
+			throw new Error(`Invalid windowId: ${windowId}`);
+		}
+		const frame = window.win.webContents.mainFrame.framesInSubtree.find(frame => {
+			return frame.name === frameName;
+		});
+		if (!frame) {
+			throw new Error(`Unknown frame: ${frameName}`);
+		}
+		return frame;
+	}
 }

src/vs/platform/webview/electron-main/webviewProtocolProvider.ts

@@ -3,11 +3,10 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { protocol, session } from 'electron';
+import { protocol } from 'electron';
 import { Disposable } from 'vs/base/common/lifecycle';
 import { FileAccess, Schemas } from 'vs/base/common/network';
 import { URI } from 'vs/base/common/uri';
-import { webviewPartitionId } from 'vs/platform/webview/common/webviewManagerService';
 
 
 export class WebviewProtocolProvider extends Disposable {
@@ -15,24 +14,19 @@ export class WebviewProtocolProvider extends Disposable {
 	private static validWebviewFilePaths = new Map([
 		['/index.html', 'index.html'],
 		['/fake.html', 'fake.html'],
-		['/electron-browser-index.html', 'index.html'],
 		['/main.js', 'main.js'],
-		['/host.js', 'host.js'],
 		['/service-worker.js', 'service-worker.js'],
 	]);
 
 	constructor() {
 		super();
 
-		const sess = session.fromPartition(webviewPartitionId);
-
-		// Register the protocol loading webview html
+		// Register the protocol for loading webview html
 		const webviewHandler = this.handleWebviewRequest.bind(this);
 		protocol.registerFileProtocol(Schemas.vscodeWebview, webviewHandler);
-		sess.protocol.registerFileProtocol(Schemas.vscodeWebview, webviewHandler);
 	}
 
-	private async handleWebviewRequest(
+	private handleWebviewRequest(
 		request: Electron.ProtocolRequest,
 		callback: (response: string | Electron.ProtocolResponse) => void
 	) {
@@ -40,16 +34,15 @@ export class WebviewProtocolProvider extends Disposable {
 			const uri = URI.parse(request.url);
 			const entry = WebviewProtocolProvider.validWebviewFilePaths.get(uri.path);
 			if (typeof entry === 'string') {
-				const relativeResourcePath = uri.path.startsWith('/electron-browser')
-					? `vs/workbench/contrib/webview/electron-browser/pre/${entry}`
-					: `vs/workbench/contrib/webview/browser/pre/${entry}`;
-
+				const relativeResourcePath = `vs/workbench/contrib/webview/browser/pre/${entry}`;
 				const url = FileAccess.asFileUri(relativeResourcePath, require);
 				return callback(decodeURIComponent(url.fsPath));
+			} else {
+				return callback({ error: -10 /* ACCESS_DENIED - https://cs.chromium.org/chromium/src/net/base/net_error_list.h?l=32 */ });
 			}
 		} catch {
 			// noop
 		}
-		callback({ error: -10 /* ACCESS_DENIED - https://cs.chromium.org/chromium/src/net/base/net_error_list.h?l=32 */ });
+		return callback({ error: -2 /* FAILED - https://cs.chromium.org/chromium/src/net/base/net_error_list.h?l=32 */ });
 	}
 }