@codingame/monaco-vscode-extensions-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/services/extensions/browser/extensionService.js

@@ -1,284 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { getLogs } from 'vscode/vscode/vs/platform/log/browser/log';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { IRemoteAuthorityResolverService, RemoteAuthorityResolverError } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
-import { IRemoteExtensionsScannerService } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { IWorkspaceTrustManagementService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
-import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
-import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService, IWebExtensionsScannerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
-import { WebWorkerExtensionHost } from './webWorkerExtensionHost.js';
-import { FetchFileSystemProvider } from './webWorkerFileSystemProvider.js';
-import { AbstractExtensionService, ResolvedExtensions, checkEnabledAndProposedAPI } from '../common/abstractExtensionService.js';
-import { extensionRunningPreferenceToString, extensionHostKindToString } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostKind';
-import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
-import { filterExtensionDescriptions } from '../common/extensionRunningLocationTracker.js';
-import { toExtensionDescription, ExtensionHostExtensions } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-import { dedupExtensions } from '../common/extensionsUtil.js';
-import { RemoteExtensionHost } from '../common/remoteExtensionHost.js';
-import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
-import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
-import { IUserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit';
-import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
-import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-
-var BrowserExtensionHostKindPicker_1;
-let ExtensionService = class ExtensionService extends AbstractExtensionService {
-    constructor(extensionsProposedApi, extensionHostFactory, extensionHostKindPicker, instantiationService, notificationService, _browserEnvironmentService, telemetryService, extensionEnablementService, fileService, productService, extensionManagementService, contextService, configurationService, extensionManifestPropertiesService, _webExtensionsScannerService, logService, remoteAgentService, remoteExtensionsScannerService, lifecycleService, remoteAuthorityResolverService, _userDataInitializationService, _userDataProfileService, _workspaceTrustManagementService, _remoteExplorerService, dialogService) {
-        super(extensionsProposedApi, extensionHostFactory, extensionHostKindPicker, instantiationService, notificationService, _browserEnvironmentService, telemetryService, extensionEnablementService, fileService, productService, extensionManagementService, contextService, configurationService, extensionManifestPropertiesService, logService, remoteAgentService, remoteExtensionsScannerService, lifecycleService, remoteAuthorityResolverService, dialogService);
-        this._browserEnvironmentService = _browserEnvironmentService;
-        this._webExtensionsScannerService = _webExtensionsScannerService;
-        this._userDataInitializationService = _userDataInitializationService;
-        this._userDataProfileService = _userDataProfileService;
-        this._workspaceTrustManagementService = _workspaceTrustManagementService;
-        this._remoteExplorerService = _remoteExplorerService;
-        lifecycleService.when(2 ).then(async () => {
-            await this._userDataInitializationService.initializeInstalledExtensions(this._instantiationService);
-            this._initialize();
-        });
-        this._initFetchFileSystem();
-    }
-    async _scanSingleExtension(extension) {
-        if (extension.location.scheme === Schemas.vscodeRemote) {
-            return this._remoteExtensionsScannerService.scanSingleExtension(extension.location, extension.type === 0 );
-        }
-        const scannedExtension = await this._webExtensionsScannerService.scanExistingExtension(extension.location, extension.type, this._userDataProfileService.currentProfile.extensionsResource);
-        if (scannedExtension) {
-            return toExtensionDescription(scannedExtension);
-        }
-        return null;
-    }
-    _initFetchFileSystem() {
-        const provider = ( new FetchFileSystemProvider());
-        this._register(this._fileService.registerProvider(Schemas.http, provider));
-        this._register(this._fileService.registerProvider(Schemas.https, provider));
-    }
-    async _scanWebExtensions() {
-        const system = [], user = [], development = [];
-        try {
-            await Promise.all([
-                this._webExtensionsScannerService.scanSystemExtensions().then(extensions => system.push(...( extensions.map(e => toExtensionDescription(e))))),
-                this._webExtensionsScannerService.scanUserExtensions(this._userDataProfileService.currentProfile.extensionsResource, { skipInvalidExtensions: true }).then(extensions => user.push(...( extensions.map(e => toExtensionDescription(e))))),
-                this._webExtensionsScannerService.scanExtensionsUnderDevelopment().then(extensions => development.push(...( extensions.map(e => toExtensionDescription(e, true)))))
-            ]);
-        }
-        catch (error) {
-            this._logService.error(error);
-        }
-        return dedupExtensions(system, user, development, this._logService);
-    }
-    async _resolveExtensionsDefault() {
-        const [localExtensions, remoteExtensions] = await Promise.all([
-            this._scanWebExtensions(),
-            this._remoteExtensionsScannerService.scanExtensions()
-        ]);
-        return ( new ResolvedExtensions(
-            localExtensions,
-            remoteExtensions,
-             false,
-             true
-        ));
-    }
-    async _resolveExtensions() {
-        if (!this._browserEnvironmentService.expectsResolverExtension) {
-            return this._resolveExtensionsDefault();
-        }
-        const remoteAuthority = this._environmentService.remoteAuthority;
-        await this._workspaceTrustManagementService.workspaceResolved;
-        let resolverResult;
-        try {
-            resolverResult = await this._resolveAuthorityInitial(remoteAuthority);
-        }
-        catch (err) {
-            if (RemoteAuthorityResolverError.isHandled(err)) {
-                console.log(`Error handled: Not showing a notification for the error`);
-            }
-            this._remoteAuthorityResolverService._setResolvedAuthorityError(remoteAuthority, err);
-            return this._resolveExtensionsDefault();
-        }
-        this._remoteAuthorityResolverService._setResolvedAuthority(resolverResult.authority, resolverResult.options);
-        this._remoteExplorerService.setTunnelInformation(resolverResult.tunnelInformation);
-        const connection = this._remoteAgentService.getConnection();
-        if (connection) {
-            connection.onDidStateChange(async (e) => {
-                if (e.type === 0 ) {
-                    this._remoteAuthorityResolverService._clearResolvedAuthority(remoteAuthority);
-                }
-            });
-            connection.onReconnecting(() => this._resolveAuthorityAgain());
-        }
-        return this._resolveExtensionsDefault();
-    }
-    async _onExtensionHostExit(code) {
-        this._doStopExtensionHosts();
-        const automatedWindow = mainWindow;
-        if (typeof automatedWindow.codeAutomationExit === 'function') {
-            automatedWindow.codeAutomationExit(code, await getLogs(this._fileService, this._environmentService));
-        }
-    }
-    async _resolveAuthority(remoteAuthority) {
-        return this._resolveAuthorityOnExtensionHosts(2 , remoteAuthority);
-    }
-};
-ExtensionService = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IBrowserWorkbenchEnvironmentService)),
-    ( __param(6, ITelemetryService)),
-    ( __param(7, IWorkbenchExtensionEnablementService)),
-    ( __param(8, IFileService)),
-    ( __param(9, IProductService)),
-    ( __param(10, IWorkbenchExtensionManagementService)),
-    ( __param(11, IWorkspaceContextService)),
-    ( __param(12, IConfigurationService)),
-    ( __param(13, IExtensionManifestPropertiesService)),
-    ( __param(14, IWebExtensionsScannerService)),
-    ( __param(15, ILogService)),
-    ( __param(16, IRemoteAgentService)),
-    ( __param(17, IRemoteExtensionsScannerService)),
-    ( __param(18, ILifecycleService)),
-    ( __param(19, IRemoteAuthorityResolverService)),
-    ( __param(20, IUserDataInitializationService)),
-    ( __param(21, IUserDataProfileService)),
-    ( __param(22, IWorkspaceTrustManagementService)),
-    ( __param(23, IRemoteExplorerService)),
-    ( __param(24, IDialogService))
-], ExtensionService));
-let BrowserExtensionHostFactory = class BrowserExtensionHostFactory {
-    constructor(_extensionsProposedApi, _scanWebExtensions, _getExtensionRegistrySnapshotWhenReady, _instantiationService, _remoteAgentService, _remoteAuthorityResolverService, _extensionEnablementService, _logService) {
-        this._extensionsProposedApi = _extensionsProposedApi;
-        this._scanWebExtensions = _scanWebExtensions;
-        this._getExtensionRegistrySnapshotWhenReady = _getExtensionRegistrySnapshotWhenReady;
-        this._instantiationService = _instantiationService;
-        this._remoteAgentService = _remoteAgentService;
-        this._remoteAuthorityResolverService = _remoteAuthorityResolverService;
-        this._extensionEnablementService = _extensionEnablementService;
-        this._logService = _logService;
-    }
-    createExtensionHost(runningLocations, runningLocation, isInitialStart) {
-        switch (runningLocation.kind) {
-            case 1 : {
-                return null;
-            }
-            case 2 : {
-                const startup = ((isInitialStart ? 2  : 1) );
-                return this._instantiationService.createInstance(WebWorkerExtensionHost, runningLocation, startup, this._createLocalExtensionHostDataProvider(runningLocations, runningLocation, isInitialStart));
-            }
-            case 3 : {
-                const remoteAgentConnection = this._remoteAgentService.getConnection();
-                if (remoteAgentConnection) {
-                    return this._instantiationService.createInstance(RemoteExtensionHost, runningLocation, this._createRemoteExtensionHostDataProvider(runningLocations, remoteAgentConnection.remoteAuthority));
-                }
-                return null;
-            }
-        }
-    }
-    _createLocalExtensionHostDataProvider(runningLocations, desiredRunningLocation, isInitialStart) {
-        return {
-            getInitData: async () => {
-                if (isInitialStart) {
-                    const localExtensions = checkEnabledAndProposedAPI(this._logService, this._extensionEnablementService, this._extensionsProposedApi, await this._scanWebExtensions(),  true);
-                    const runningLocation = runningLocations.computeRunningLocation(localExtensions, [], false);
-                    const myExtensions = filterExtensionDescriptions(localExtensions, runningLocation, extRunningLocation => desiredRunningLocation.equals(extRunningLocation));
-                    const extensions = ( new ExtensionHostExtensions(0, localExtensions, ( myExtensions.map(extension => extension.identifier))));
-                    return { extensions };
-                }
-                else {
-                    const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
-                    const myExtensions = runningLocations.filterByRunningLocation(snapshot.extensions, desiredRunningLocation);
-                    const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
-                    return { extensions };
-                }
-            }
-        };
-    }
-    _createRemoteExtensionHostDataProvider(runningLocations, remoteAuthority) {
-        return {
-            remoteAuthority: remoteAuthority,
-            getInitData: async () => {
-                const snapshot = await this._getExtensionRegistrySnapshotWhenReady();
-                const remoteEnv = await this._remoteAgentService.getEnvironment();
-                if (!remoteEnv) {
-                    throw new Error('Cannot provide init data for remote extension host!');
-                }
-                const myExtensions = runningLocations.filterByExtensionHostKind(snapshot.extensions, 3 );
-                const extensions = ( new ExtensionHostExtensions(snapshot.versionId, snapshot.extensions, ( myExtensions.map(extension => extension.identifier))));
-                return {
-                    connectionData: this._remoteAuthorityResolverService.getConnectionData(remoteAuthority),
-                    pid: remoteEnv.pid,
-                    appRoot: remoteEnv.appRoot,
-                    extensionHostLogsPath: remoteEnv.extensionHostLogsPath,
-                    globalStorageHome: remoteEnv.globalStorageHome,
-                    workspaceStorageHome: remoteEnv.workspaceStorageHome,
-                    extensions,
-                };
-            }
-        };
-    }
-};
-BrowserExtensionHostFactory = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IRemoteAgentService)),
-    ( __param(5, IRemoteAuthorityResolverService)),
-    ( __param(6, IWorkbenchExtensionEnablementService)),
-    ( __param(7, ILogService))
-], BrowserExtensionHostFactory));
-let BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = class BrowserExtensionHostKindPicker {
-    constructor(_logService) {
-        this._logService = _logService;
-    }
-    pickExtensionHostKind(extensionId, extensionKinds, isInstalledLocally, isInstalledRemotely, preference) {
-        const result = BrowserExtensionHostKindPicker_1.pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference);
-        this._logService.trace(`pickRunningLocation for ${extensionId.value}, extension kinds: [${extensionKinds.join(', ')}], isInstalledLocally: ${isInstalledLocally}, isInstalledRemotely: ${isInstalledRemotely}, preference: ${extensionRunningPreferenceToString(preference)} => ${extensionHostKindToString(result)}`);
-        return result;
-    }
-    static pickRunningLocation(extensionKinds, isInstalledLocally, isInstalledRemotely, preference) {
-        const result = [];
-        let canRunRemotely = false;
-        for (const extensionKind of extensionKinds) {
-            if (extensionKind === 'ui' && isInstalledRemotely) {
-                if (preference === 2 ) {
-                    return 3 ;
-                }
-                else {
-                    canRunRemotely = true;
-                }
-            }
-            if (extensionKind === 'workspace' && isInstalledRemotely) {
-                if (preference === 0  || preference === 2 ) {
-                    return 3 ;
-                }
-                else {
-                    result.push(3 );
-                }
-            }
-            if (extensionKind === 'web' && (isInstalledLocally || isInstalledRemotely)) {
-                if (preference === 0  || preference === 1 ) {
-                    return 2 ;
-                }
-                else {
-                    result.push(2 );
-                }
-            }
-        }
-        if (canRunRemotely) {
-            result.push(3 );
-        }
-        return (result.length > 0 ? result[0] : null);
-    }
-};
-BrowserExtensionHostKindPicker = BrowserExtensionHostKindPicker_1 = ( __decorate([
-    ( __param(0, ILogService))
-], BrowserExtensionHostKindPicker));
-
-export { BrowserExtensionHostFactory, BrowserExtensionHostKindPicker, ExtensionService };

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerExtensionHost.js

@@ -1,276 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { addDisposableListener } from 'vscode/vscode/vs/base/browser/dom';
-import { parentOriginHash } from 'vscode/vscode/vs/base/browser/iframe';
-import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { Barrier } from 'vscode/vscode/vs/base/common/async';
-import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
-import { canceled, onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { COI, FileAccess } from 'vscode/vscode/vs/base/common/network';
-import { isWeb, Language, language } from 'vscode/vscode/vs/base/common/platform';
-import { joinPath } from 'vscode/vscode/vs/base/common/resources';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService';
-import { ILogService, ILoggerService } from 'vscode/vscode/vs/platform/log/common/log';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { isLoggingOnly } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
-import { IUserDataProfilesService } from 'vscode/vscode/vs/platform/userDataProfile/common/userDataProfile';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
-import { isMessageOfType, createMessageOfType, UIKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionHostProtocol';
-
-let WebWorkerExtensionHost = class WebWorkerExtensionHost extends Disposable {
-    constructor(runningLocation, startup, _initDataProvider, _telemetryService, _contextService, _labelService, _logService, _loggerService, _environmentService, _userDataProfilesService, _productService, _layoutService, _storageService) {
-        super();
-        this.runningLocation = runningLocation;
-        this.startup = startup;
-        this._initDataProvider = _initDataProvider;
-        this._telemetryService = _telemetryService;
-        this._contextService = _contextService;
-        this._labelService = _labelService;
-        this._logService = _logService;
-        this._loggerService = _loggerService;
-        this._environmentService = _environmentService;
-        this._userDataProfilesService = _userDataProfilesService;
-        this._productService = _productService;
-        this._layoutService = _layoutService;
-        this._storageService = _storageService;
-        this.pid = null;
-        this.remoteAuthority = null;
-        this.extensions = null;
-        this._onDidExit = this._register(( new Emitter()));
-        this.onExit = this._onDidExit.event;
-        this._isTerminating = false;
-        this._protocolPromise = null;
-        this._protocol = null;
-        this._extensionHostLogsLocation = joinPath(this._environmentService.extHostLogsPath, 'webWorker');
-    }
-    async _getWebWorkerExtensionHostIframeSrc() {
-        const suffixSearchParams = ( new URLSearchParams());
-        if (this._environmentService.debugExtensionHost && this._environmentService.debugRenderer) {
-            suffixSearchParams.set('debugged', '1');
-        }
-        COI.addSearchParam(suffixSearchParams, true, true);
-        const suffix = `?${( suffixSearchParams.toString())}`;
-        const iframeModulePath = 'vs/workbench/services/extensions/worker/webWorkerExtensionHostIframe.html';
-        if (isWeb) {
-            const webEndpointUrlTemplate = this._productService.webEndpointUrlTemplate;
-            const commit = this._productService.commit;
-            const quality = this._productService.quality;
-            if (webEndpointUrlTemplate && commit && quality) {
-                const key = 'webWorkerExtensionHostIframeStableOriginUUID';
-                let stableOriginUUID = this._storageService.get(key, 1 );
-                if (typeof stableOriginUUID === 'undefined') {
-                    stableOriginUUID = generateUuid();
-                    this._storageService.store(key, stableOriginUUID, 1 , 1 );
-                }
-                const hash = await parentOriginHash(mainWindow.origin, stableOriginUUID);
-                const baseUrl = (webEndpointUrlTemplate
-                    .replace('{{uuid}}', `v--${hash}`)
-                    .replace('{{commit}}', commit)
-                    .replace('{{quality}}', quality));
-                const res = ( new URL(`${baseUrl}/out/${iframeModulePath}${suffix}`));
-                res.searchParams.set('parentOrigin', mainWindow.origin);
-                res.searchParams.set('salt', stableOriginUUID);
-                return ( res.toString());
-            }
-        }
-        const relativeExtensionHostIframeSrc = ( FileAccess.asBrowserUri(iframeModulePath));
-        return `${( relativeExtensionHostIframeSrc.toString(true))}${suffix}`;
-    }
-    async start() {
-        if (!this._protocolPromise) {
-            this._protocolPromise = this._startInsideIframe();
-            this._protocolPromise.then(protocol => this._protocol = protocol);
-        }
-        return this._protocolPromise;
-    }
-    async _startInsideIframe() {
-        const webWorkerExtensionHostIframeSrc = await this._getWebWorkerExtensionHostIframeSrc();
-        const emitter = this._register(( new Emitter()));
-        const iframe = document.createElement('iframe');
-        iframe.setAttribute('class', 'web-worker-ext-host-iframe');
-        iframe.setAttribute('sandbox', 'allow-scripts allow-same-origin');
-        iframe.setAttribute('allow', 'usb; serial; hid; cross-origin-isolated;');
-        iframe.setAttribute('aria-hidden', 'true');
-        iframe.style.display = 'none';
-        const vscodeWebWorkerExtHostId = generateUuid();
-        iframe.setAttribute('src', `${webWorkerExtensionHostIframeSrc}&vscodeWebWorkerExtHostId=${vscodeWebWorkerExtHostId}`);
-        const barrier = ( new Barrier());
-        let port;
-        let barrierError = null;
-        let barrierHasError = false;
-        let startTimeout = null;
-        const rejectBarrier = (exitCode, error) => {
-            barrierError = error;
-            barrierHasError = true;
-            onUnexpectedError(barrierError);
-            clearTimeout(startTimeout);
-            this._onDidExit.fire([81 , barrierError.message]);
-            barrier.open();
-        };
-        const resolveBarrier = (messagePort) => {
-            port = messagePort;
-            clearTimeout(startTimeout);
-            barrier.open();
-        };
-        startTimeout = setTimeout(() => {
-            console.warn(`The Web Worker Extension Host did not start in 60s, that might be a problem.`);
-        }, 60000);
-        this._register(addDisposableListener(mainWindow, 'message', (event) => {
-            if (event.source !== iframe.contentWindow) {
-                return;
-            }
-            if (event.data.vscodeWebWorkerExtHostId !== vscodeWebWorkerExtHostId) {
-                return;
-            }
-            if (event.data.error) {
-                const { name, message, stack } = event.data.error;
-                const err = ( new Error());
-                err.message = message;
-                err.name = name;
-                err.stack = stack;
-                return rejectBarrier(81 , err);
-            }
-            const { data } = event.data;
-            if (barrier.isOpen() || !(data instanceof MessagePort)) {
-                console.warn('UNEXPECTED message', event);
-                const err = ( new Error('UNEXPECTED message'));
-                return rejectBarrier(81 , err);
-            }
-            resolveBarrier(data);
-        }));
-        this._layoutService.mainContainer.appendChild(iframe);
-        this._register(toDisposable(() => iframe.remove()));
-        await barrier.wait();
-        if (barrierHasError) {
-            throw barrierError;
-        }
-        const messagePorts = this._environmentService.options?.messagePorts ?? ( new Map());
-        iframe.contentWindow.postMessage({ type: 'vscode.init', data: messagePorts }, '*', [...( messagePorts.values())]);
-        port.onmessage = (event) => {
-            const { data } = event;
-            if (!(data instanceof ArrayBuffer)) {
-                console.warn('UNKNOWN data received', data);
-                this._onDidExit.fire([77, 'UNKNOWN data received']);
-                return;
-            }
-            emitter.fire(VSBuffer.wrap(( new Uint8Array(data, 0, data.byteLength))));
-        };
-        const protocol = {
-            onMessage: emitter.event,
-            send: vsbuf => {
-                const data = vsbuf.buffer.buffer.slice(vsbuf.buffer.byteOffset, vsbuf.buffer.byteOffset + vsbuf.buffer.byteLength);
-                port.postMessage(data, [data]);
-            }
-        };
-        return this._performHandshake(protocol);
-    }
-    async _performHandshake(protocol) {
-        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, 1 )));
-        if (this._isTerminating) {
-            throw canceled();
-        }
-        protocol.send(VSBuffer.fromString(JSON.stringify(await this._createExtHostInitData())));
-        if (this._isTerminating) {
-            throw canceled();
-        }
-        await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, 0 )));
-        if (this._isTerminating) {
-            throw canceled();
-        }
-        return protocol;
-    }
-    dispose() {
-        if (this._isTerminating) {
-            return;
-        }
-        this._isTerminating = true;
-        this._protocol?.send(createMessageOfType(2 ));
-        super.dispose();
-    }
-    getInspectPort() {
-        return undefined;
-    }
-    enableInspectPort() {
-        return Promise.resolve(false);
-    }
-    async _createExtHostInitData() {
-        const initData = await this._initDataProvider.getInitData();
-        this.extensions = initData.extensions;
-        const workspace = this._contextService.getWorkspace();
-        const nlsBaseUrl = this._productService.extensionsGallery?.nlsBaseUrl;
-        let nlsUrlWithDetails = undefined;
-        if (nlsBaseUrl && this._productService.commit && !Language.isDefaultVariant()) {
-            nlsUrlWithDetails = URI.joinPath(( URI.parse(nlsBaseUrl)), this._productService.commit, this._productService.version, Language.value());
-        }
-        return {
-            commit: this._productService.commit,
-            version: this._productService.version,
-            quality: this._productService.quality,
-            parentPid: 0,
-            environment: {
-                isExtensionDevelopmentDebug: this._environmentService.debugRenderer,
-                appName: this._productService.nameLong,
-                appHost: this._productService.embedderIdentifier ?? (isWeb ? 'web' : 'desktop'),
-                appUriScheme: this._productService.urlProtocol,
-                appLanguage: language,
-                extensionTelemetryLogResource: this._environmentService.extHostTelemetryLogFile,
-                isExtensionTelemetryLoggingOnly: isLoggingOnly(this._productService, this._environmentService),
-                extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
-                extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
-                globalStorageHome: this._userDataProfilesService.defaultProfile.globalStorageHome,
-                workspaceStorageHome: this._environmentService.workspaceStorageHome,
-                extensionLogLevel: this._environmentService.extensionLogLevel
-            },
-            workspace: this._contextService.getWorkbenchState() === 1  ? undefined : {
-                configuration: workspace.configuration || undefined,
-                id: workspace.id,
-                name: this._labelService.getWorkspaceLabel(workspace),
-                transient: workspace.transient
-            },
-            consoleForward: {
-                includeStack: false,
-                logNative: this._environmentService.debugRenderer
-            },
-            extensions: this.extensions.toSnapshot(),
-            nlsBaseUrl: nlsUrlWithDetails,
-            telemetryInfo: {
-                sessionId: this._telemetryService.sessionId,
-                machineId: this._telemetryService.machineId,
-                sqmId: this._telemetryService.sqmId,
-                firstSessionDate: this._telemetryService.firstSessionDate,
-                msftInternal: this._telemetryService.msftInternal
-            },
-            logLevel: this._logService.getLevel(),
-            loggers: [...this._loggerService.getRegisteredLoggers()],
-            logsLocation: this._extensionHostLogsLocation,
-            autoStart: ((this.startup === 1) ),
-            remote: {
-                authority: this._environmentService.remoteAuthority,
-                connectionData: null,
-                isRemote: false
-            },
-            uiKind: isWeb ? UIKind.Web : UIKind.Desktop
-        };
-    }
-};
-WebWorkerExtensionHost = ( __decorate([
-    ( __param(3, ITelemetryService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, ILabelService)),
-    ( __param(6, ILogService)),
-    ( __param(7, ILoggerService)),
-    ( __param(8, IBrowserWorkbenchEnvironmentService)),
-    ( __param(9, IUserDataProfilesService)),
-    ( __param(10, IProductService)),
-    ( __param(11, ILayoutService)),
-    ( __param(12, IStorageService))
-], WebWorkerExtensionHost));
-
-export { WebWorkerExtensionHost };

package/vscode/src/vs/workbench/services/extensions/browser/webWorkerFileSystemProvider.js

@@ -1,52 +0,0 @@
-import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'vscode/vscode/vs/platform/files/common/files';
-import { Event } from 'vscode/vscode/vs/base/common/event';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { NotSupportedError } from 'vscode/vscode/vs/base/common/errors';
-
-class FetchFileSystemProvider {
-    constructor() {
-        this.capabilities = 2048  + 2  + 1024 ;
-        this.onDidChangeCapabilities = Event.None;
-        this.onDidChangeFile = Event.None;
-    }
-    async readFile(resource) {
-        try {
-            const res = await fetch(( resource.toString(true)));
-            if (res.status === 200) {
-                return ( new Uint8Array(await res.arrayBuffer()));
-            }
-            throw createFileSystemProviderError(res.statusText, FileSystemProviderErrorCode.Unknown);
-        }
-        catch (err) {
-            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
-        }
-    }
-    async stat(_resource) {
-        return {
-            type: FileType.File,
-            size: 0,
-            mtime: 0,
-            ctime: 0
-        };
-    }
-    watch() {
-        return Disposable.None;
-    }
-    writeFile(_resource, _content, _opts) {
-        throw new NotSupportedError();
-    }
-    readdir(_resource) {
-        throw new NotSupportedError();
-    }
-    mkdir(_resource) {
-        throw new NotSupportedError();
-    }
-    delete(_resource, _opts) {
-        throw new NotSupportedError();
-    }
-    rename(_from, _to, _opts) {
-        throw new NotSupportedError();
-    }
-}
-
-export { FetchFileSystemProvider };