chrome-devtools-frontend 1.0.1040337 → 1.0.1070764

package/front_end/models/bindings/DebuggerWorkspaceBinding.ts

@@ -14,21 +14,22 @@ import {DefaultScriptMapping} from './DefaultScriptMapping.js';
 import {IgnoreListManager} from './IgnoreListManager.js';
 
 import {LiveLocationWithPool, type LiveLocation, type LiveLocationPool} from './LiveLocation.js';
-import {ResourceMapping} from './ResourceMapping.js';
+import {type ResourceMapping} from './ResourceMapping.js';
 
 import {ResourceScriptMapping, type ResourceScriptFile} from './ResourceScriptMapping.js';
 
 let debuggerWorkspaceBindingInstance: DebuggerWorkspaceBinding|undefined;
 
 export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObserver<SDK.DebuggerModel.DebuggerModel> {
-  readonly workspace: Workspace.Workspace.WorkspaceImpl;
+  readonly resourceMapping: ResourceMapping;
   readonly #sourceMappings: DebuggerSourceMapping[];
   readonly #debuggerModelToData: Map<SDK.DebuggerModel.DebuggerModel, ModelData>;
   readonly #liveLocationPromises: Set<Promise<void|Location|StackTraceTopFrameLocation|null>>;
   pluginManager: DebuggerLanguagePluginManager|null;
   #targetManager: SDK.TargetManager.TargetManager;
-  private constructor(targetManager: SDK.TargetManager.TargetManager, workspace: Workspace.Workspace.WorkspaceImpl) {
-    this.workspace = workspace;
+
+  private constructor(resourceMapping: ResourceMapping, targetManager: SDK.TargetManager.TargetManager) {
+    this.resourceMapping = resourceMapping;
 
     this.#sourceMappings = [];
 
@@ -43,14 +44,15 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
     this.#liveLocationPromises = new Set();
 
     this.pluginManager = Root.Runtime.experiments.isEnabled('wasmDWARFDebugging') ?
-        new DebuggerLanguagePluginManager(targetManager, workspace, this) :
+        new DebuggerLanguagePluginManager(targetManager, resourceMapping.workspace, this) :
         null;
   }
 
   initPluginManagerForTest(): DebuggerLanguagePluginManager|null {
     if (Root.Runtime.experiments.isEnabled('wasmDWARFDebugging')) {
       if (!this.pluginManager) {
-        this.pluginManager = new DebuggerLanguagePluginManager(this.#targetManager, this.workspace, this);
+        this.pluginManager =
+            new DebuggerLanguagePluginManager(this.#targetManager, this.resourceMapping.workspace, this);
       }
     } else {
       this.pluginManager = null;
@@ -60,17 +62,18 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
 
   static instance(opts: {
     forceNew: boolean|null,
+    resourceMapping: ResourceMapping|null,
     targetManager: SDK.TargetManager.TargetManager|null,
-    workspace: Workspace.Workspace.WorkspaceImpl|null,
-  } = {forceNew: null, targetManager: null, workspace: null}): DebuggerWorkspaceBinding {
-    const {forceNew, targetManager, workspace} = opts;
+  } = {forceNew: null, resourceMapping: null, targetManager: null}): DebuggerWorkspaceBinding {
+    const {forceNew, resourceMapping, targetManager} = opts;
     if (!debuggerWorkspaceBindingInstance || forceNew) {
-      if (!targetManager || !workspace) {
-        throw new Error(`Unable to create DebuggerWorkspaceBinding: targetManager and workspace must be provided: ${
-            new Error().stack}`);
+      if (!resourceMapping || !targetManager) {
+        throw new Error(
+            `Unable to create DebuggerWorkspaceBinding: resourceMapping and targetManager must be provided: ${
+                new Error().stack}`);
       }
 
-      debuggerWorkspaceBindingInstance = new DebuggerWorkspaceBinding(targetManager, workspace);
+      debuggerWorkspaceBindingInstance = new DebuggerWorkspaceBinding(resourceMapping, targetManager);
     }
 
     return debuggerWorkspaceBindingInstance;
@@ -305,7 +308,7 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
   scriptFile(uiSourceCode: Workspace.UISourceCode.UISourceCode, debuggerModel: SDK.DebuggerModel.DebuggerModel):
       ResourceScriptFile|null {
     const modelData = this.#debuggerModelToData.get(debuggerModel);
-    return modelData ? modelData.getResourceMapping().scriptFile(uiSourceCode) : null;
+    return modelData ? modelData.getResourceScriptMapping().scriptFile(uiSourceCode) : null;
   }
 
   scriptsForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): SDK.Script.Script[] {
@@ -314,7 +317,7 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
       this.pluginManager.scriptsForUISourceCode(uiSourceCode).forEach(script => scripts.add(script));
     }
     for (const modelData of this.#debuggerModelToData.values()) {
-      const resourceScriptFile = modelData.getResourceMapping().scriptFile(uiSourceCode);
+      const resourceScriptFile = modelData.getResourceScriptMapping().scriptFile(uiSourceCode);
       if (resourceScriptFile && resourceScriptFile.script) {
         scripts.add(resourceScriptFile.script);
       }
@@ -323,17 +326,6 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
     return [...scripts];
   }
 
-  scriptsForResource(uiSourceCode: Workspace.UISourceCode.UISourceCode): SDK.Script.Script[] {
-    const scripts = new Set<SDK.Script.Script>();
-    for (const modelData of this.#debuggerModelToData.values()) {
-      const resourceScriptFile = modelData.getResourceMapping().scriptFile(uiSourceCode);
-      if (resourceScriptFile && resourceScriptFile.script) {
-        scripts.add(resourceScriptFile.script);
-      }
-    }
-    return [...scripts];
-  }
-
   supportsConditionalBreakpoints(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
     // DevTools traditionally supported (JavaScript) conditions
     // for breakpoints everywhere, so we keep that behavior...
@@ -371,7 +363,7 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
     const debuggerModel = (target.model(SDK.DebuggerModel.DebuggerModel) as SDK.DebuggerModel.DebuggerModel);
     const modelData = this.#debuggerModelToData.get(debuggerModel);
     if (modelData) {
-      modelData.getResourceMapping().resetForTest();
+      modelData.getResourceScriptMapping().resetForTest();
     }
   }
 
@@ -400,18 +392,21 @@ class ModelData {
   readonly #debuggerWorkspaceBinding: DebuggerWorkspaceBinding;
   callFrameLocations: Set<Location>;
   #defaultMapping: DefaultScriptMapping;
-  resourceMapping: ResourceScriptMapping;
+  readonly #resourceMapping: ResourceMapping;
+  #resourceScriptMapping: ResourceScriptMapping;
   readonly compilerMapping: CompilerScriptMapping;
   readonly #locations: Platform.MapUtilities.Multimap<string, Location>;
+
   constructor(debuggerModel: SDK.DebuggerModel.DebuggerModel, debuggerWorkspaceBinding: DebuggerWorkspaceBinding) {
     this.#debuggerModel = debuggerModel;
     this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
 
     this.callFrameLocations = new Set();
 
-    const workspace = debuggerWorkspaceBinding.workspace;
+    const {workspace} = debuggerWorkspaceBinding.resourceMapping;
     this.#defaultMapping = new DefaultScriptMapping(debuggerModel, workspace, debuggerWorkspaceBinding);
-    this.resourceMapping = new ResourceScriptMapping(debuggerModel, workspace, debuggerWorkspaceBinding);
+    this.#resourceMapping = debuggerWorkspaceBinding.resourceMapping;
+    this.#resourceScriptMapping = new ResourceScriptMapping(debuggerModel, workspace, debuggerWorkspaceBinding);
     this.compilerMapping = new CompilerScriptMapping(debuggerModel, workspace, debuggerWorkspaceBinding);
 
     this.#locations = new Platform.MapUtilities.Multimap();
@@ -444,8 +439,8 @@ class ModelData {
 
   rawLocationToUILocation(rawLocation: SDK.DebuggerModel.Location): Workspace.UISourceCode.UILocation|null {
     let uiLocation = this.compilerMapping.rawLocationToUILocation(rawLocation);
-    uiLocation = uiLocation || this.resourceMapping.rawLocationToUILocation(rawLocation);
-    uiLocation = uiLocation || ResourceMapping.instance().jsLocationToUILocation(rawLocation);
+    uiLocation = uiLocation || this.#resourceScriptMapping.rawLocationToUILocation(rawLocation);
+    uiLocation = uiLocation || this.#resourceMapping.jsLocationToUILocation(rawLocation);
     uiLocation = uiLocation || this.#defaultMapping.rawLocationToUILocation(rawLocation);
     return uiLocation;
   }
@@ -457,10 +452,10 @@ class ModelData {
     let locations = this.compilerMapping.uiLocationToRawLocations(uiSourceCode, lineNumber, columnNumber);
     locations = locations.length ?
         locations :
-        this.resourceMapping.uiLocationToRawLocations(uiSourceCode, lineNumber, columnNumber);
+        this.#resourceScriptMapping.uiLocationToRawLocations(uiSourceCode, lineNumber, columnNumber);
     locations = locations.length ?
         locations :
-        ResourceMapping.instance().uiLocationToJSLocations(uiSourceCode, lineNumber, columnNumber);
+        this.#resourceMapping.uiLocationToJSLocations(uiSourceCode, lineNumber, columnNumber);
     locations = locations.length ?
         locations :
         this.#defaultMapping.uiLocationToRawLocations(uiSourceCode, lineNumber, columnNumber);
@@ -474,12 +469,12 @@ class ModelData {
   dispose(): void {
     this.#debuggerModel.setBeforePausedCallback(null);
     this.compilerMapping.dispose();
-    this.resourceMapping.dispose();
+    this.#resourceScriptMapping.dispose();
     this.#defaultMapping.dispose();
   }
 
-  getResourceMapping(): ResourceScriptMapping {
-    return this.resourceMapping;
+  getResourceScriptMapping(): ResourceScriptMapping {
+    return this.#resourceScriptMapping;
   }
 }
 

package/front_end/models/bindings/FileUtils.ts

@@ -163,19 +163,19 @@ export class ChunkedFileReader implements ChunkedReader {
     }
 
     if (endOfFile) {
-      this.finishRead();
+      void this.finishRead();
       return;
     }
     void this.loadChunk();
   }
 
-  private finishRead(): void {
+  private async finishRead(): Promise<void> {
     if (!this.#output) {
       return;
     }
     this.#file = null;
     this.#reader = null;
-    void this.#output.close();
+    await this.#output.close();
     this.#transferFinished(!this.#errorInternal);
   }
 

package/front_end/models/bindings/IgnoreListManager.ts

@@ -31,6 +31,9 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
     Common.Settings.Settings.instance()
         .moduleSetting('automaticallyIgnoreListKnownThirdPartyScripts')
         .addChangeListener(this.patternChanged.bind(this));
+    Common.Settings.Settings.instance()
+        .moduleSetting('enableIgnoreListing')
+        .addChangeListener(this.patternChanged.bind(this));
 
     this.#listeners = new Set();
 
@@ -90,7 +93,7 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
   }
 
   private setIgnoreListPatterns(debuggerModel: SDK.DebuggerModel.DebuggerModel): Promise<boolean> {
-    const regexPatterns = this.getSkipStackFramesPatternSetting().getAsArray();
+    const regexPatterns = this.enableIgnoreListing ? this.getSkipStackFramesPatternSetting().getAsArray() : [];
     const patterns = ([] as string[]);
     for (const item of regexPatterns) {
       if (!item.disabled && item.pattern) {
@@ -121,6 +124,9 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
   }
 
   isUserIgnoreListedURL(url: Platform.DevToolsPath.UrlString, isContentScript?: boolean): boolean {
+    if (!this.enableIgnoreListing) {
+      return false;
+    }
     if (this.#isIgnoreListedURLCache.has(url)) {
       return Boolean(this.#isIgnoreListedURLCache.get(url));
     }
@@ -217,12 +223,17 @@ export class IgnoreListManager implements SDK.TargetManager.SDKModelObserver<SDK
     }
   }
 
+  get enableIgnoreListing(): boolean {
+    return Common.Settings.Settings.instance().moduleSetting('enableIgnoreListing').get();
+  }
+
   get skipContentScripts(): boolean {
-    return Common.Settings.Settings.instance().moduleSetting('skipContentScripts').get();
+    return this.enableIgnoreListing && Common.Settings.Settings.instance().moduleSetting('skipContentScripts').get();
   }
 
   get automaticallyIgnoreListKnownThirdPartyScripts(): boolean {
-    return Common.Settings.Settings.instance().moduleSetting('automaticallyIgnoreListKnownThirdPartyScripts').get();
+    return this.enableIgnoreListing &&
+        Common.Settings.Settings.instance().moduleSetting('automaticallyIgnoreListKnownThirdPartyScripts').get();
   }
 
   ignoreListContentScripts(): void {

package/front_end/models/bindings/ResourceMapping.ts

@@ -14,45 +14,22 @@ import {DebuggerWorkspaceBinding} from './DebuggerWorkspaceBinding.js';
 import {NetworkProject} from './NetworkProject.js';
 import {resourceMetadata} from './ResourceUtils.js';
 
-let resourceMappingInstance: ResourceMapping|undefined;
-
 const styleSheetOffsetMap = new WeakMap<SDK.CSSStyleSheetHeader.CSSStyleSheetHeader, TextUtils.TextRange.TextRange>();
 const scriptOffsetMap = new WeakMap<SDK.Script.Script, TextUtils.TextRange.TextRange>();
 const boundUISourceCodes = new WeakSet<Workspace.UISourceCode.UISourceCode>();
 
 export class ResourceMapping implements SDK.TargetManager.SDKModelObserver<SDK.ResourceTreeModel.ResourceTreeModel> {
-  readonly #workspace: Workspace.Workspace.WorkspaceImpl;
+  readonly workspace: Workspace.Workspace.WorkspaceImpl;
   readonly #modelToInfo: Map<SDK.ResourceTreeModel.ResourceTreeModel, ModelInfo>;
-  private constructor(targetManager: SDK.TargetManager.TargetManager, workspace: Workspace.Workspace.WorkspaceImpl) {
-    this.#workspace = workspace;
+
+  constructor(targetManager: SDK.TargetManager.TargetManager, workspace: Workspace.Workspace.WorkspaceImpl) {
+    this.workspace = workspace;
     this.#modelToInfo = new Map();
     targetManager.observeModels(SDK.ResourceTreeModel.ResourceTreeModel, this);
   }
 
-  static instance(opts: {
-    forceNew: boolean|null,
-    targetManager: SDK.TargetManager.TargetManager|null,
-    workspace: Workspace.Workspace.WorkspaceImpl|null,
-  } = {forceNew: null, targetManager: null, workspace: null}): ResourceMapping {
-    const {forceNew, targetManager, workspace} = opts;
-    if (!resourceMappingInstance || forceNew) {
-      if (!targetManager || !workspace) {
-        throw new Error(
-            `Unable to create ResourceMapping: targetManager and workspace must be provided: ${new Error().stack}`);
-      }
-
-      resourceMappingInstance = new ResourceMapping(targetManager, workspace);
-    }
-
-    return resourceMappingInstance;
-  }
-
-  static removeInstance(): void {
-    resourceMappingInstance = undefined;
-  }
-
   modelAdded(resourceTreeModel: SDK.ResourceTreeModel.ResourceTreeModel): void {
-    const info = new ModelInfo(this.#workspace, resourceTreeModel);
+    const info = new ModelInfo(this.workspace, resourceTreeModel);
     this.#modelToInfo.set(resourceTreeModel, info);
   }
 

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -30,7 +30,7 @@
 
 import * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
-import * as Platform from '../../core/platform/platform.js';
+import type * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 import * as Workspace from '../workspace/workspace.js';
@@ -90,17 +90,6 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     ];
   }
 
-  static resolveRelativeSourceURL(script: SDK.Script.Script, url: Platform.DevToolsPath.UrlString):
-      Platform.DevToolsPath.UrlString {
-    let target: SDK.Target.Target|null = script.debuggerModel.target();
-    while (target && target.type() !== SDK.Target.Type.Frame) {
-      target = target.parentTarget();
-    }
-    const baseURL = target?.inspectedURL() ?? Platform.DevToolsPath.EmptyUrlString;
-    url = Common.ParsedURL.ParsedURL.completeURL(baseURL, url) ?? url;
-    return url;
-  }
-
   private project(script: SDK.Script.Script): ContentProviderBasedProject {
     const prefix = script.isContentScript() ? 'js:extensions:' : 'js::';
     const projectId = prefix + this.debuggerModel.target().id() + ':' + script.frameId;
@@ -183,7 +172,7 @@ export class ResourceScriptMapping implements DebuggerSourceMapping {
     if (script.hasSourceURL) {
       // Try to resolve `//# sourceURL=` annotations relative to
       // the base URL, according to the sourcemap specification.
-      url = ResourceScriptMapping.resolveRelativeSourceURL(script, url);
+      url = SDK.SourceMapManager.SourceMapManager.resolveRelativeSourceURL(script.debuggerModel.target(), url);
     } else {
       // Ignore inline <script>s without `//# sourceURL` annotation here.
       if (script.isInlineScript()) {

package/front_end/models/bindings/ResourceUtils.ts

@@ -64,8 +64,7 @@ export function displayNameForURL(url: Platform.DevToolsPath.UrlString): string
     return uiSourceCode.displayName();
   }
 
-  const mainTarget = SDK.TargetManager.TargetManager.instance().mainTarget();
-  const inspectedURL = mainTarget && mainTarget.inspectedURL();
+  const inspectedURL = SDK.TargetManager.TargetManager.instance().inspectedURL();
   if (!inspectedURL) {
     return Platform.StringUtilities.trimURL(url, '');
   }

package/front_end/models/emulation/DeviceModeModel.ts

@@ -722,24 +722,22 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper<EventTyp
       return null;
     }
 
+    let screenshotMode;
+    if (clip) {
+      screenshotMode = SDK.ScreenCaptureModel.ScreenshotMode.FROM_CLIP;
+    } else if (fullSize) {
+      screenshotMode = SDK.ScreenCaptureModel.ScreenshotMode.FULLPAGE;
+    } else {
+      screenshotMode = SDK.ScreenCaptureModel.ScreenshotMode.FROM_VIEWPORT;
+    }
+
     const overlayModel = this.#emulationModel ? this.#emulationModel.overlayModel() : null;
     if (overlayModel) {
       overlayModel.setShowViewportSizeOnResize(false);
     }
 
-    // Define the right clipping area for fullsize screenshots.
-    if (fullSize) {
-      const metrics = await screenCaptureModel.fetchLayoutMetrics();
-      if (!metrics) {
-        return null;
-      }
-
-      // Cap the height to not hit the GPU limit.
-      const contentHeight = Math.min((1 << 14), metrics.contentHeight);
-      clip = {x: 0, y: 0, width: Math.floor(metrics.contentWidth), height: Math.floor(contentHeight), scale: 1};
-    }
-    const screenshot =
-        await screenCaptureModel.captureScreenshot(Protocol.Page.CaptureScreenshotRequestFormat.Png, 100, clip);
+    const screenshot = await screenCaptureModel.captureScreenshot(
+        Protocol.Page.CaptureScreenshotRequestFormat.Png, 100, screenshotMode, clip);
 
     const deviceMetrics: Protocol.Page.SetDeviceMetricsOverrideRequest = {
       width: 0,

package/front_end/models/extensions/ExtensionAPI.ts

@@ -344,6 +344,7 @@ export type ExtensionDescriptor = {
   name: string,
   exposeExperimentalAPIs: boolean,
   exposeWebInspectorNamespace?: boolean,
+  allowFileAccess?: boolean,
 };
 
 namespace APIImpl {
@@ -638,7 +639,9 @@ self.injectedExtensionAPI = function(
         userAction = true;
         try {
           const {resource, lineNumber} = message as {resource: APIImpl.ResourceData, lineNumber: number};
-          callback.call(null, new (Constructor(Resource))(resource), lineNumber);
+          if (canAccessResource(resource)) {
+            callback.call(null, new (Constructor(Resource))(resource), lineNumber);
+          }
         } finally {
           userAction = false;
         }
@@ -1134,17 +1137,28 @@ self.injectedExtensionAPI = function(
     this.onRecordingStopped = new (Constructor(EventSink))(PrivateAPI.Events.RecordingStopped + id);
   }
 
+  function canAccessResource(resource: APIImpl.ResourceData): boolean {
+    return extensionInfo.allowFileAccess || !resource.url.startsWith('file://');
+  }
+
   function InspectedWindow(this: PublicAPI.Chrome.DevTools.InspectedWindow): void {
     function dispatchResourceEvent(
         this: APIImpl.EventSink<(resource: APIImpl.Resource) => unknown>, message: {arguments: unknown[]}): void {
-      this._fire(new (Constructor(Resource))(message.arguments[0] as APIImpl.ResourceData));
+      const resourceData = message.arguments[0] as APIImpl.ResourceData;
+      if (!canAccessResource(resourceData)) {
+        return;
+      }
+      this._fire(new (Constructor(Resource))(resourceData));
     }
 
     function dispatchResourceContentEvent(
         this: APIImpl.EventSink<(resource: APIImpl.Resource, content: string) => unknown>,
         message: {arguments: unknown[]}): void {
-      this._fire(
-          new (Constructor(Resource))(message.arguments[0] as APIImpl.ResourceData), message.arguments[1] as string);
+      const resourceData = message.arguments[0] as APIImpl.ResourceData;
+      if (!canAccessResource(resourceData)) {
+        return;
+      }
+      this._fire(new (Constructor(Resource))(resourceData), message.arguments[1] as string);
     }
 
     this.onResourceAdded = new (Constructor(EventSink))(PrivateAPI.Events.ResourceAdded, dispatchResourceEvent);
@@ -1206,13 +1220,16 @@ self.injectedExtensionAPI = function(
         return new (Constructor(Resource))(resourceData);
       }
       function callbackWrapper(resources: unknown): void {
-        callback && callback((resources as APIImpl.ResourceData[]).map(wrapResource));
+        callback && callback((resources as APIImpl.ResourceData[]).map(wrapResource).filter(canAccessResource));
       }
       extensionServer.sendRequest({command: PrivateAPI.Commands.GetPageResources}, callback && callbackWrapper);
     },
   };
 
   function ResourceImpl(this: APIImpl.Resource, resourceData: APIImpl.ResourceData): void {
+    if (!canAccessResource) {
+      throw new Error('Resource access not allowed');
+    }
     this._url = resourceData.url;
     this._type = resourceData.type;
   }

package/front_end/models/extensions/ExtensionServer.ts

@@ -296,7 +296,7 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
       this.disableExtensions();
       return;
     }
-    if (event.data !== SDK.TargetManager.TargetManager.instance().mainTarget()) {
+    if (event.data !== SDK.TargetManager.TargetManager.instance().mainFrameTarget()) {
       return;
     }
     this.requests = new Map();
@@ -437,7 +437,10 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
       return this.status.E_EXISTS(id);
     }
 
-    const page = this.expandResourcePath(this.getExtensionOrigin(port), message.page) as string;
+    const page = ExtensionServer.expandResourcePath(this.getExtensionOrigin(port), message.page);
+    if (page === undefined) {
+      return this.status.E_BADARG('page', 'Resources paths cannot point to non-extension resources');
+    }
     let persistentId = this.getExtensionOrigin(port) + message.title;
     persistentId = persistentId.replace(/\s/g, '');
     const panelView = new ExtensionServerPanelView(
@@ -469,9 +472,11 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     if (!panelView || !(panelView instanceof ExtensionServerPanelView)) {
       return this.status.E_NOTFOUND(message.panel);
     }
-    const button = new ExtensionButton(
-        this, message.id, this.expandResourcePath(this.getExtensionOrigin(port), message.icon), message.tooltip,
-        message.disabled);
+    const resourcePath = ExtensionServer.expandResourcePath(this.getExtensionOrigin(port), message.icon);
+    if (resourcePath === undefined) {
+      return this.status.E_BADARG('icon', 'Resources paths cannot point to non-extension resources');
+    }
+    const button = new ExtensionButton(this, message.id, resourcePath, message.tooltip, message.disabled);
     this.clientObjects.set(message.id, button);
 
     void panelView.widget().then(appendButton);
@@ -491,9 +496,12 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     if (!button || !(button instanceof ExtensionButton)) {
       return this.status.E_NOTFOUND(message.id);
     }
-    button.update(
-        message.icon && this.expandResourcePath(this.getExtensionOrigin(port), message.icon), message.tooltip,
-        message.disabled);
+    const resourcePath =
+        message.icon && ExtensionServer.expandResourcePath(this.getExtensionOrigin(port), message.icon);
+    if (message.icon && resourcePath === undefined) {
+      return this.status.E_BADARG('icon', 'Resources paths cannot point to non-extension resources');
+    }
+    button.update(resourcePath, message.tooltip, message.disabled);
     return this.status.OK();
   }
 
@@ -569,7 +577,11 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     if (!sidebar || !(sidebar instanceof ExtensionSidebarPane)) {
       return this.status.E_NOTFOUND(message.id);
     }
-    sidebar.setPage(this.expandResourcePath(this.getExtensionOrigin(port), message.page));
+    const resourcePath = ExtensionServer.expandResourcePath(this.getExtensionOrigin(port), message.page);
+    if (resourcePath === undefined) {
+      return this.status.E_BADARG('page', 'Resources paths cannot point to non-extension resources');
+    }
+    sidebar.setPage(resourcePath);
     return undefined;
   }
 
@@ -941,7 +953,7 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   private addExtension(extensionInfo: Host.InspectorFrontendHostAPI.ExtensionDescriptor): boolean|undefined {
     const startPage = extensionInfo.startPage;
 
-    const inspectedURL = SDK.TargetManager.TargetManager.instance().mainTarget()?.inspectedURL() ?? '';
+    const inspectedURL = SDK.TargetManager.TargetManager.instance().mainFrameTarget()?.inspectedURL() ?? '';
     if (inspectedURL !== '' && !this.canInspectURL(inspectedURL)) {
       this.disableExtensions();
     }
@@ -1063,9 +1075,14 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
         removeLastEventListener.bind(this));
   }
 
-  private expandResourcePath(extensionPath: Platform.DevToolsPath.UrlString, resourcePath: string):
-      Platform.DevToolsPath.UrlString {
-    return extensionPath + '/' + Common.ParsedURL.normalizePath(resourcePath) as Platform.DevToolsPath.UrlString;
+  static expandResourcePath(extensionOrigin: Platform.DevToolsPath.UrlString, resourcePath: string):
+      Platform.DevToolsPath.UrlString|undefined {
+    const strippedOrigin = new URL(extensionOrigin).origin;
+    const resourceURL = new URL(Common.ParsedURL.normalizePath(resourcePath), strippedOrigin);
+    if (resourceURL.origin !== strippedOrigin) {
+      return undefined;
+    }
+    return resourceURL.href as Platform.DevToolsPath.UrlString;
   }
 
   evaluate(
@@ -1091,7 +1108,7 @@ export class ExtensionServer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     if (options.frameURL) {
       frame = resolveURLToFrame(options.frameURL as Platform.DevToolsPath.UrlString);
     } else {
-      const target = SDK.TargetManager.TargetManager.instance().mainTarget();
+      const target = SDK.TargetManager.TargetManager.instance().mainFrameTarget();
       const resourceTreeModel = target && target.model(SDK.ResourceTreeModel.ResourceTreeModel);
       frame = resourceTreeModel && resourceTreeModel.mainFrame;
     }

package/front_end/models/formatter/FormatterWorkerPool.ts

@@ -125,14 +125,6 @@ export class FormatterWorkerPool {
     return this.runTask(FormatterActions.FormatterActions.FORMAT, parameters) as Promise<FormatterActions.FormatResult>;
   }
 
-  javaScriptIdentifiers(content: string): Promise<{
-    name: string,
-    offset: number,
-  }[]> {
-    return this.runTask(FormatterActions.FormatterActions.JAVASCRIPT_IDENTIFIERS, {content: content})
-        .then(ids => ids || []);
-  }
-
   javaScriptSubstitute(expression: string, mapping: Map<string, string>): Promise<string> {
     return this
         .runTask(
@@ -162,29 +154,6 @@ export class FormatterWorkerPool {
     }
   }
 
-  outlineForMimetype(content: string, mimeType: string, callback: (arg0: boolean, arg1: Array<OutlineItem>) => void):
-      boolean {
-    switch (mimeType) {
-      case 'text/html':
-        this.runChunkedTask(FormatterActions.FormatterActions.HTML_OUTLINE, {content: content}, callback);
-        return true;
-      case 'text/javascript':
-        this.runChunkedTask(FormatterActions.FormatterActions.JAVASCRIPT_OUTLINE, {content: content}, callback);
-        return true;
-      case 'text/css':
-        this.parseCSS(content, cssCallback);
-        return true;
-    }
-    return false;
-
-    function cssCallback(isLastChunk: boolean, rules: CSSRule[]): void {
-      callback(isLastChunk, rules.map(rule => {
-        const title = 'selectorText' in rule ? rule.selectorText : rule.atRule;
-        return {line: rule.lineNumber, subtitle: undefined, column: rule.columnNumber, title};
-      }));
-    }
-  }
-
   argumentsList(content: string): Promise<string[]> {
     return this.runTask(FormatterActions.FormatterActions.ARGUMENTS_LIST, {content}) as Promise<string[]>;
   }