chrome-devtools-frontend 1.0.1040857 → 1.0.1070764

package/front_end/legacy/legacy-defs.d.ts

@@ -91,7 +91,6 @@ interface Node {
   enclosingNodeOrSelfWithClass(className: string, stayWithin?: Element): Element;
   getComponentRoot(): Document|DocumentFragment|null;
   getComponentSelection(): Selection|null;
-  hasSameShadowRoot(other: Node): boolean;
   hasSelection(): boolean;
   isAncestor(node: Node|null): boolean;
   isDescendant(node: Node|null): boolean;
@@ -101,14 +100,13 @@ interface Node {
   parentNodeOrShadowHost(): Node|null;
   setTextContentTruncatedIfNeeded(text: any, placeholder?: string): boolean;
   traverseNextNode(stayWithin?: Node): Node|null;
+  traversePreviousNode(stayWithin?: Node): Node|null;
   deepTextContent(): string
   window(): Window;
   childTextNodes(): Node[];
   __widget?: any;
 }
 
-declare function isEnterOrSpaceKey(event: Event): boolean;
-declare function isEscKey(event: Event): boolean;
 declare function onInvokeElement(element: Element, callback: (event: Event) => void): void;
 
 // The following types exist in Chrome but were removed for various reasons

package/front_end/legacy_test_runner/network_test_runner/network_test_runner.js

@@ -59,7 +59,7 @@ NetworkTestRunner.recordNetwork = function() {
 };
 
 NetworkTestRunner.networkWaterfallColumn = function() {
-  return UI.panels.network.networkLogView.columns.waterfallColumn;
+  return UI.panels.network.networkLogView.columns().waterfallColumn;
 };
 
 NetworkTestRunner.networkRequests = function() {

package/front_end/legacy_test_runner/performance_test_runner/TimelineTestRunner.js

@@ -102,8 +102,7 @@ PerformanceTestRunner.invokeWithTracing = function(functionName, callback, addit
   }
 
   function onPageActionsDone() {
-    PerformanceTestRunner.runWhenTimelineIsReady(callback);
-    timelineController.stopRecording();
+    timelineController.stopRecording().then(callback);
   }
 };
 
@@ -119,25 +118,25 @@ PerformanceTestRunner.timelineFrameModel = function() {
   return PerformanceTestRunner.performanceModel().frameModel();
 };
 
-PerformanceTestRunner.createPerformanceModelWithEvents = function(events) {
+PerformanceTestRunner.createPerformanceModelWithEvents = async function(events) {
   const tracingModel = new SDK.TracingModel(new Bindings.TempFileBackingStorage('tracing'));
   tracingModel.addEvents(events);
   tracingModel.tracingComplete();
   const performanceModel = new Timeline.PerformanceModel();
-  performanceModel.setTracingModel(tracingModel);
+  await performanceModel.setTracingModel(tracingModel);
   UI.panels.timeline.performanceModel = performanceModel;
   UI.panels.timeline.applyFilters(performanceModel);
   return performanceModel;
 };
 
 PerformanceTestRunner.createTimelineController = function() {
-  const controller = new Timeline.TimelineController(self.SDK.targetManager.mainTarget(), UI.panels.timeline);
+  const controller = new Timeline.TimelineController(self.SDK.targetManager.mainFrameTarget(), UI.panels.timeline);
   controller.tracingManager = TestRunner.tracingManager;
   return controller;
 };
 
 PerformanceTestRunner.runWhenTimelineIsReady = function(callback) {
-  TestRunner.addSniffer(UI.panels.timeline, 'loadingComplete', () => callback());
+  TestRunner.addSniffer(UI.panels.timeline, 'loadingCompleteForTest', () => callback());
 };
 
 PerformanceTestRunner.startTimeline = function() {
@@ -146,11 +145,8 @@ PerformanceTestRunner.startTimeline = function() {
   return TestRunner.addSnifferPromise(panel, 'recordingStarted');
 };
 
-PerformanceTestRunner.stopTimeline = function() {
-  return new Promise(resolve => {
-    PerformanceTestRunner.runWhenTimelineIsReady(resolve);
-    UI.panels.timeline.toggleRecording();
-  });
+PerformanceTestRunner.stopTimeline = async function() {
+  await UI.panels.timeline.toggleRecording();
 };
 
 PerformanceTestRunner.runPerfTraceWithReload = async function() {
@@ -287,7 +283,7 @@ PerformanceTestRunner.printTraceEventProperties = function(traceEvent) {
 PerformanceTestRunner.printTraceEventPropertiesWithDetails = async function(event) {
   PerformanceTestRunner.printTraceEventProperties(event);
   const details = await Timeline.TimelineUIUtils.buildDetailsTextForTraceEvent(
-      event, self.SDK.targetManager.mainTarget(), new Components.Linkifier());
+      event, self.SDK.targetManager.mainFrameTarget(), new Components.Linkifier());
   TestRunner.waitForPendingLiveLocationUpdates();
   TestRunner.addResult(`Text details for ${event.name}: ${details}`);
 
@@ -405,12 +401,8 @@ PerformanceTestRunner.dumpTimelineFlameChart = function(includeGroups) {
   PerformanceTestRunner.dumpFlameChartProvider(provider, includeGroups);
 };
 
-PerformanceTestRunner.loadTimeline = function(timelineData) {
-  const promise = new Promise(fulfill => PerformanceTestRunner.runWhenTimelineIsReady(fulfill));
-
-  UI.panels.timeline.loadFromFile(new Blob([timelineData], {type: 'text/plain'}));
-
-  return promise;
+PerformanceTestRunner.loadTimeline = async function(timelineData) {
+  await UI.panels.timeline.loadFromFile(new Blob([timelineData], {type: 'text/plain'}));
 };
 
 TestRunner.deprecatedInitAsync(`

package/front_end/legacy_test_runner/sources_test_runner/DebuggerTestRunner.js

@@ -7,14 +7,14 @@
  */
 self.SourcesTestRunner = self.SourcesTestRunner || {};
 
-SourcesTestRunner.startDebuggerTest = function(callback, quiet) {
+SourcesTestRunner.startDebuggerTest = async function(callback, quiet) {
   console.assert(TestRunner.debuggerModel.debuggerEnabled(), 'Debugger has to be enabled');
 
   if (quiet !== undefined) {
     SourcesTestRunner.quiet = quiet;
   }
 
-  self.UI.viewManager.showView('sources');
+  await TestRunner.showPanel('sources');
   TestRunner.addSniffer(SDK.DebuggerModel.prototype, 'pausedScript', SourcesTestRunner.pausedScript, true);
   TestRunner.addSniffer(SDK.DebuggerModel.prototype, 'resumedScript', SourcesTestRunner.resumedScript, true);
   TestRunner.safeWrap(callback)();
@@ -628,7 +628,7 @@ SourcesTestRunner.queryScripts = function(filter) {
 
 SourcesTestRunner.createScriptMock = function(
     url, startLine, startColumn, isContentScript, source, target, preRegisterCallback) {
-  target = target || self.SDK.targetManager.mainTarget();
+  target = target || self.SDK.targetManager.mainFrameTarget();
   const debuggerModel = target.model(SDK.DebuggerModel);
   const scriptId = String(++SourcesTestRunner.lastScriptId);
   const sourceLineEndings = TestRunner.findLineEndingIndexes(source);

package/front_end/legacy_test_runner/test_runner/TestRunner.js

@@ -234,6 +234,29 @@ export function addSnifferPromise(receiver, methodName) {
   });
 }
 
+/**
+ * @param {Text} textNode
+ * @param {number=} start
+ * @param {number=} end
+ * @return {Text}
+ */
+export function selectTextInTextNode(textNode, start, end) {
+  start = start || 0;
+  end = end || textNode.textContent.length;
+
+  if (start < 0) {
+    start = end + start;
+  }
+
+  const selection = textNode.getComponentSelection();
+  selection.removeAllRanges();
+  const range = textNode.ownerDocument.createRange();
+  range.setStart(textNode, start);
+  range.setEnd(textNode, end);
+  selection.addRange(range);
+  return textNode;
+}
+
 const mappingForLayoutTests = new Map([
   ['panels/animation', 'animation'],
   ['panels/browser_debugger', 'browser_debugger'],
@@ -1506,5 +1529,6 @@ TestRunner.runAsyncTestSuite = runAsyncTestSuite;
 TestRunner.dumpInspectedPageElementText = dumpInspectedPageElementText;
 TestRunner.waitForPendingLiveLocationUpdates = waitForPendingLiveLocationUpdates;
 TestRunner.findLineEndingIndexes = findLineEndingIndexes;
+TestRunner.selectTextInTextNode = selectTextInTextNode;
 
 TestRunner.isScrolledToBottom = UI.UIUtils.isScrolledToBottom;

package/front_end/legacy_test_runner/test_runner/test_runner.js

@@ -36,6 +36,7 @@ function _setupTestHelpers(target) {
 
   self.TestRunner.networkManager = target.model(SDK.NetworkManager);
   self.TestRunner.securityOriginManager = target.model(SDK.SecurityOriginManager);
+  self.TestRunner.storageKeyManager = target.model(SDK.StorageKeyManager);
   self.TestRunner.resourceTreeModel = target.model(SDK.ResourceTreeModel);
   self.TestRunner.debuggerModel = target.model(SDK.DebuggerModel);
   self.TestRunner.runtimeModel = target.model(SDK.RuntimeModel);
@@ -86,21 +87,22 @@ export class _TestObserver {
    * @override
    */
   targetAdded(target) {
-    if (target.id() === 'main') {
+    if (target.id() === 'main' && target.type() === 'frame' ||
+        target.parentTarget()?.type() === 'tab' && target.type() === 'frame' && !target.targetInfo()?.subtype?.length) {
       _setupTestHelpers(target);
+      if (_startedTest) {
+        return;
+      }
+      _startedTest = true;
+      TestRunner
+          .loadHTML(`
+        <head>
+          <base href="${TestRunner.url()}">
+        </head>
+        <body>
+        </body>
+      `).then(() => _executeTestScript());
     }
-    if (_startedTest) {
-      return;
-    }
-    _startedTest = true;
-    TestRunner
-        .loadHTML(`
-      <head>
-        <base href="${TestRunner.url()}">
-      </head>
-      <body>
-      </body>
-    `).then(() => _executeTestScript());
   }
 
   /**

package/front_end/models/bindings/BreakpointManager.ts

@@ -40,7 +40,6 @@ import {DebuggerWorkspaceBinding} from './DebuggerWorkspaceBinding.js';
 
 import {LiveLocationPool, type LiveLocation} from './LiveLocation.js';
 import {DefaultScriptMapping} from './DefaultScriptMapping.js';
-import {ResourceScriptMapping} from './ResourceScriptMapping.js';
 
 let breakpointManagerInstance: BreakpointManager;
 
@@ -119,7 +118,8 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
       Promise<void> {
     const breakpointItems = this.storage.breakpointItems(fromURL);
     for (const item of breakpointItems) {
-      await this.setBreakpoint(toSourceCode, item.lineNumber, item.columnNumber, item.condition, item.enabled);
+      await this.setBreakpoint(
+          toSourceCode, item.lineNumber, item.columnNumber, item.condition, item.enabled, BreakpointOrigin.OTHER);
     }
   }
 
@@ -184,7 +184,8 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
     if (isInlineScriptWithoutSourceURL) {
       sourceURL = DefaultScriptMapping.createV8ScriptURL(script);
     } else if (hasResourceScriptMapping) {
-      sourceURL = ResourceScriptMapping.resolveRelativeSourceURL(script, script.sourceURL);
+      sourceURL = SDK.SourceMapManager.SourceMapManager.resolveRelativeSourceURL(
+          script.debuggerModel.target(), script.sourceURL);
     }
 
     const uiSourceCode =
@@ -227,7 +228,8 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
     this.storage.mute();
     const breakpointItems = this.storage.breakpointItems(url);
     for (const item of breakpointItems) {
-      this.innerSetBreakpoint(uiSourceCode, item.lineNumber, item.columnNumber, item.condition, item.enabled);
+      this.innerSetBreakpoint(
+          uiSourceCode, item.lineNumber, item.columnNumber, item.condition, item.enabled, BreakpointOrigin.OTHER);
     }
     this.storage.unmute();
   }
@@ -256,7 +258,7 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
 
   async setBreakpoint(
       uiSourceCode: Workspace.UISourceCode.UISourceCode, lineNumber: number, columnNumber: number|undefined,
-      condition: string, enabled: boolean): Promise<Breakpoint> {
+      condition: string, enabled: boolean, origin: BreakpointOrigin): Promise<Breakpoint> {
     let uiLocation: Workspace.UISourceCode.UILocation =
         new Workspace.UISourceCode.UILocation(uiSourceCode, lineNumber, columnNumber);
     const normalizedLocation = await this.debuggerWorkspaceBinding.normalizeUILocation(uiLocation);
@@ -265,12 +267,12 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
       uiLocation = normalizedLocation;
     }
     return this.innerSetBreakpoint(
-        uiLocation.uiSourceCode, uiLocation.lineNumber, uiLocation.columnNumber, condition, enabled);
+        uiLocation.uiSourceCode, uiLocation.lineNumber, uiLocation.columnNumber, condition, enabled, origin);
   }
 
   private innerSetBreakpoint(
       uiSourceCode: Workspace.UISourceCode.UISourceCode, lineNumber: number, columnNumber: number|undefined,
-      condition: string, enabled: boolean): Breakpoint {
+      condition: string, enabled: boolean, origin: BreakpointOrigin): Breakpoint {
     const itemId = BreakpointManager.breakpointStorageId(uiSourceCode.url(), lineNumber, columnNumber);
     let breakpoint = this.#breakpointByStorageId.get(itemId);
     if (breakpoint) {
@@ -279,7 +281,8 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
       void breakpoint.updateBreakpoint();
       return breakpoint;
     }
-    breakpoint = new Breakpoint(this, uiSourceCode, uiSourceCode.url(), lineNumber, columnNumber, condition, enabled);
+    breakpoint =
+        new Breakpoint(this, uiSourceCode, uiSourceCode.url(), lineNumber, columnNumber, condition, enabled, origin);
     this.#breakpointByStorageId.set(itemId, breakpoint);
     return breakpoint;
   }
@@ -386,7 +389,7 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
       breakpoints = new Map();
       this.#breakpointsForUISourceCode.set(uiLocation.uiSourceCode, breakpoints);
     }
-    const breakpointLocation = {breakpoint: breakpoint, uiLocation: uiLocation};
+    const breakpointLocation = new BreakpointLocation(breakpoint, uiLocation);
     breakpoints.set(uiLocation.id(), breakpointLocation);
     this.dispatchEventToListeners(Events.BreakpointAdded, breakpointLocation);
   }
@@ -404,7 +407,11 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
     if (breakpoints.size === 0) {
       this.#breakpointsForUISourceCode.delete(uiLocation.uiSourceCode);
     }
-    this.dispatchEventToListeners(Events.BreakpointRemoved, {breakpoint: breakpoint, uiLocation: uiLocation});
+    this.dispatchEventToListeners(Events.BreakpointRemoved, breakpointLocation);
+  }
+
+  supportsConditionalBreakpoints(uiSourceCode: Workspace.UISourceCode.UISourceCode): boolean {
+    return this.debuggerWorkspaceBinding.supportsConditionalBreakpoints(uiSourceCode);
   }
 }
 
@@ -446,6 +453,7 @@ export class Breakpoint implements SDK.TargetManager.SDKModelObserver<SDK.Debugg
   uiSourceCodes: Set<Workspace.UISourceCode.UISourceCode>;
   #conditionInternal!: string;
   #enabledInternal!: boolean;
+  #origin: BreakpointOrigin;
   isRemoved = false;
   currentState: Breakpoint.State|null;
   readonly #modelBreakpoints: Map<SDK.DebuggerModel.DebuggerModel, ModelBreakpoint>;
@@ -453,11 +461,12 @@ export class Breakpoint implements SDK.TargetManager.SDKModelObserver<SDK.Debugg
   constructor(
       breakpointManager: BreakpointManager, primaryUISourceCode: Workspace.UISourceCode.UISourceCode,
       url: Platform.DevToolsPath.UrlString, lineNumber: number, columnNumber: number|undefined, condition: string,
-      enabled: boolean) {
+      enabled: boolean, origin: BreakpointOrigin) {
     this.breakpointManager = breakpointManager;
     this.urlInternal = url;
     this.#lineNumberInternal = lineNumber;
     this.#columnNumberInternal = columnNumber;
+    this.#origin = origin;
 
     this.#uiLocations = new Set();   // Bound locations
     this.uiSourceCodes = new Set();  // All known UISourceCodes with this url
@@ -470,6 +479,10 @@ export class Breakpoint implements SDK.TargetManager.SDKModelObserver<SDK.Debugg
     this.breakpointManager.targetManager.observeModels(SDK.DebuggerModel.DebuggerModel, this);
   }
 
+  get origin(): BreakpointOrigin {
+    return this.#origin;
+  }
+
   async refreshInDebugger(): Promise<void> {
     if (!this.isRemoved) {
       const modelBreakpoints = Array.from(this.#modelBreakpoints.values());
@@ -793,7 +806,6 @@ export class ModelBreakpoint {
           const script = loc.script() as SDK.Script.Script;
           return {
             url: script.sourceURL,
-            scriptId: script.scriptId,
             scriptHash: script.hash,
             lineNumber: loc.lineNumber,
             columnNumber: loc.columnNumber,
@@ -811,7 +823,6 @@ export class ModelBreakpoint {
           // really resolved.
           const position = {
             url: this.#breakpoint.url(),
-            scriptId: '' as Protocol.Runtime.ScriptId,
             scriptHash: '',
             lineNumber,
             columnNumber,
@@ -894,7 +905,7 @@ export class ModelBreakpoint {
         return this.#debuggerModel.setBreakpointByURL(pos.url, pos.lineNumber, pos.columnNumber, condition);
       }
       return this.#debuggerModel.setBreakpointInAnonymousScript(
-          pos.scriptId, pos.scriptHash as string, pos.lineNumber, pos.columnNumber, condition);
+          pos.scriptHash as string, pos.lineNumber, pos.columnNumber, condition);
     }));
     const breakpointIds: Protocol.Debugger.BreakpointId[] = [];
     let locations: SDK.DebuggerModel.Location[] = [];
@@ -983,12 +994,16 @@ export class ModelBreakpoint {
 
 interface Position {
   url: Platform.DevToolsPath.UrlString;
-  scriptId: Protocol.Runtime.ScriptId;
   scriptHash: string;
   lineNumber: number;
   columnNumber?: number;
 }
 
+export const enum BreakpointOrigin {
+  USER_ACTION = 'USER_ACTION',
+  OTHER = 'RESTORED',
+}
+
 export namespace Breakpoint {
   export class State {
     positions: Position[];
@@ -1015,9 +1030,6 @@ export namespace Breakpoint {
         if (positionA.url !== positionB.url) {
           return false;
         }
-        if (positionA.scriptId !== positionB.scriptId) {
-          return false;
-        }
         if (positionA.scriptHash !== positionB.scriptHash) {
           return false;
         }
@@ -1101,7 +1113,12 @@ namespace Storage {
   }
 }
 
-export interface BreakpointLocation {
-  breakpoint: Breakpoint;
-  uiLocation: Workspace.UISourceCode.UILocation;
+export class BreakpointLocation {
+  readonly breakpoint: Breakpoint;
+  readonly uiLocation: Workspace.UISourceCode.UILocation;
+
+  constructor(breakpoint: Breakpoint, uiLocation: Workspace.UISourceCode.UILocation) {
+    this.breakpoint = breakpoint;
+    this.uiLocation = uiLocation;
+  }
 }

package/front_end/models/bindings/CSSWorkspaceBinding.ts

@@ -12,21 +12,20 @@ import {
   type LiveLocation as LiveLocationInterface,
   type LiveLocationPool,
 } from './LiveLocation.js';
-import {ResourceMapping} from './ResourceMapping.js';
+import {type ResourceMapping} from './ResourceMapping.js';
 import {SASSSourceMapping} from './SASSSourceMapping.js';
 import {StylesSourceMapping} from './StylesSourceMapping.js';
 
 let cssWorkspaceBindingInstance: CSSWorkspaceBinding|undefined;
 
 export class CSSWorkspaceBinding implements SDK.TargetManager.SDKModelObserver<SDK.CSSModel.CSSModel> {
-  readonly #workspace: Workspace.Workspace.WorkspaceImpl;
+  readonly #resourceMapping: ResourceMapping;
   readonly #modelToInfo: Map<SDK.CSSModel.CSSModel, ModelInfo>;
   readonly #sourceMappings: SourceMapping[];
   readonly #liveLocationPromises: Set<Promise<unknown>>;
 
-  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.#modelToInfo = new Map();
     this.#sourceMappings = [];
     targetManager.observeModels(SDK.CSSModel.CSSModel, this);
@@ -36,17 +35,17 @@ export class CSSWorkspaceBinding implements SDK.TargetManager.SDKModelObserver<S
 
   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}): CSSWorkspaceBinding {
-    const {forceNew, targetManager, workspace} = opts;
+  } = {forceNew: null, resourceMapping: null, targetManager: null}): CSSWorkspaceBinding {
+    const {forceNew, resourceMapping, targetManager} = opts;
     if (!cssWorkspaceBindingInstance || forceNew) {
-      if (!targetManager || !workspace) {
-        throw new Error(
-            `Unable to create CSSWorkspaceBinding: targetManager and workspace must be provided: ${new Error().stack}`);
+      if (!resourceMapping || !targetManager) {
+        throw new Error(`Unable to create CSSWorkspaceBinding: resourceMapping and targetManager must be provided: ${
+            new Error().stack}`);
       }
 
-      cssWorkspaceBindingInstance = new CSSWorkspaceBinding(targetManager, workspace);
+      cssWorkspaceBindingInstance = new CSSWorkspaceBinding(resourceMapping, targetManager);
     }
 
     return cssWorkspaceBindingInstance;
@@ -65,7 +64,7 @@ export class CSSWorkspaceBinding implements SDK.TargetManager.SDKModelObserver<S
   }
 
   modelAdded(cssModel: SDK.CSSModel.CSSModel): void {
-    this.#modelToInfo.set(cssModel, new ModelInfo(cssModel, this.#workspace));
+    this.#modelToInfo.set(cssModel, new ModelInfo(cssModel, this.#resourceMapping));
   }
 
   modelRemoved(cssModel: SDK.CSSModel.CSSModel): void {
@@ -177,11 +176,12 @@ export interface SourceMapping {
 
 export class ModelInfo {
   readonly #eventListeners: Common.EventTarget.EventDescriptor[];
+  readonly #resourceMapping: ResourceMapping;
   #stylesSourceMapping: StylesSourceMapping;
   #sassSourceMapping: SASSSourceMapping;
   readonly #locations: Platform.MapUtilities.Multimap<SDK.CSSStyleSheetHeader.CSSStyleSheetHeader, LiveLocation>;
   readonly #unboundLocations: Platform.MapUtilities.Multimap<Platform.DevToolsPath.UrlString, LiveLocation>;
-  constructor(cssModel: SDK.CSSModel.CSSModel, workspace: Workspace.Workspace.WorkspaceImpl) {
+  constructor(cssModel: SDK.CSSModel.CSSModel, resourceMapping: ResourceMapping) {
     this.#eventListeners = [
       cssModel.addEventListener(
           SDK.CSSModel.Events.StyleSheetAdded,
@@ -197,9 +197,10 @@ export class ModelInfo {
           this),
     ];
 
-    this.#stylesSourceMapping = new StylesSourceMapping(cssModel, workspace);
+    this.#resourceMapping = resourceMapping;
+    this.#stylesSourceMapping = new StylesSourceMapping(cssModel, resourceMapping.workspace);
     const sourceMapManager = cssModel.sourceMapManager();
-    this.#sassSourceMapping = new SASSSourceMapping(cssModel.target(), sourceMapManager, workspace);
+    this.#sassSourceMapping = new SASSSourceMapping(cssModel.target(), sourceMapManager, resourceMapping.workspace);
 
     this.#locations = new Platform.MapUtilities.Multimap();
     this.#unboundLocations = new Platform.MapUtilities.Multimap();
@@ -275,7 +276,7 @@ export class ModelInfo {
     let uiLocation: (Workspace.UISourceCode.UILocation|null)|null = null;
     uiLocation = uiLocation || this.#sassSourceMapping.rawLocationToUILocation(rawLocation);
     uiLocation = uiLocation || this.#stylesSourceMapping.rawLocationToUILocation(rawLocation);
-    uiLocation = uiLocation || ResourceMapping.instance().cssLocationToUILocation(rawLocation);
+    uiLocation = uiLocation || this.#resourceMapping.cssLocationToUILocation(rawLocation);
     return uiLocation;
   }
 
@@ -288,7 +289,7 @@ export class ModelInfo {
     if (rawLocations.length) {
       return rawLocations;
     }
-    return ResourceMapping.instance().uiLocationToCSSLocations(uiLocation);
+    return this.#resourceMapping.uiLocationToCSSLocations(uiLocation);
   }
 
   dispose(): void {

package/front_end/models/bindings/DebuggerLanguagePlugins.ts

@@ -796,6 +796,10 @@ export class ExtensionRemoteObject extends SDK.RemoteObject.RemoteObject {
     return this.extensionObject.linearMemoryAddress;
   }
 
+  get linearMemorySize(): number|undefined {
+    return this.extensionObject.linearMemorySize;
+  }
+
   get objectId(): Protocol.Runtime.RemoteObjectId|undefined {
     return this.extensionObject.objectId as Protocol.Runtime.RemoteObjectId;
   }