chrome-devtools-frontend 1.0.1515796 → 1.0.1516909

package/front_end/models/ai_code_completion/AiCodeCompletion.ts

@@ -159,8 +159,10 @@ export class AiCodeCompletion extends Common.ObjectWrapper.ObjectWrapper<EventTy
   }
 
   #debouncedRequestAidaSuggestion = Common.Debouncer.debounce(
-      (prefix: string, suffix: string, cursor: number, inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage) => {
-        void this.#requestAidaSuggestion(this.#buildRequest(prefix, suffix, inferenceLanguage), cursor);
+      (prefix: string, suffix: string, cursorPositionAtRequest: number,
+       inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage) => {
+        void this.#requestAidaSuggestion(
+            this.#buildRequest(prefix, suffix, inferenceLanguage), cursorPositionAtRequest);
       },
       AIDA_REQUEST_DEBOUNCE_TIMEOUT_MS);
 
@@ -288,12 +290,15 @@ export class AiCodeCompletion extends Common.ObjectWrapper.ObjectWrapper<EventTy
     };
   }
 
-  async #requestAidaSuggestion(request: Host.AidaClient.CompletionRequest, cursor: number): Promise<void> {
+  async #requestAidaSuggestion(request: Host.AidaClient.CompletionRequest, cursorPositionAtRequest: number):
+      Promise<void> {
     const startTime = performance.now();
     this.dispatchEventToListeners(Events.REQUEST_TRIGGERED, {});
+    // Registering AiCodeCompletionRequestTriggered metric even if the request is served from cache
+    Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeCompletionRequestTriggered);
 
     try {
-      const sampleResponse = await this.#generateSampleForRequest(request, cursor);
+      const sampleResponse = await this.#generateSampleForRequest(request, cursorPositionAtRequest);
       if (!sampleResponse) {
         this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {});
         return;
@@ -308,12 +313,19 @@ export class AiCodeCompletion extends Common.ObjectWrapper.ObjectWrapper<EventTy
       } = sampleResponse;
       const remainingDelay = Math.max(DELAY_BEFORE_SHOWING_RESPONSE_MS - (performance.now() - startTime), 0);
       this.#renderingTimeout = window.setTimeout(() => {
+        const currentCursorPosition = this.#editor.editor.state.selection.main.head;
+        if (currentCursorPosition !== cursorPositionAtRequest) {
+          this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {});
+          return;
+        }
         this.#editor.dispatch({
           effects: TextEditor.Config.setAiAutoCompleteSuggestion.of({
             text: suggestionText,
-            from: cursor,
+            from: cursorPositionAtRequest,
             rpcGlobalId,
             sampleId,
+            startTime,
+            onImpression: this.#registerUserImpression.bind(this),
           })
         });
 
@@ -326,12 +338,13 @@ export class AiCodeCompletion extends Common.ObjectWrapper.ObjectWrapper<EventTy
           this.#registerUserImpression(rpcGlobalId, sampleId, latency);
         }
 
-        debugLog('Suggestion dispatched to the editor', suggestionText, 'at cursor position', cursor);
+        debugLog('Suggestion dispatched to the editor', suggestionText, 'at cursor position', cursorPositionAtRequest);
         this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {citations});
       }, remainingDelay);
     } catch (e) {
       debugLog('Error while fetching code completion suggestions from AIDA', e);
       this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {});
+      Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeCompletionError);
     }
   }
 
@@ -418,6 +431,7 @@ export class AiCodeCompletion extends Common.ObjectWrapper.ObjectWrapper<EventTy
       },
     });
     debugLog('Registered user impression with latency {seconds:', seconds, ', nanos:', nanos, '}');
+    Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeCompletionSuggestionDisplayed);
   }
 
   registerUserAcceptance(rpcGlobalId: Host.AidaClient.RpcGlobalId, sampleId: number): void {
@@ -433,11 +447,13 @@ export class AiCodeCompletion extends Common.ObjectWrapper.ObjectWrapper<EventTy
       },
     });
     debugLog('Registered user acceptance');
+    Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeCompletionSuggestionAccepted);
   }
 
   onTextChanged(
-      prefix: string, suffix: string, cursor: number, inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage): void {
-    this.#debouncedRequestAidaSuggestion(prefix, suffix, cursor, inferenceLanguage);
+      prefix: string, suffix: string, cursorPositionAtRequest: number,
+      inferenceLanguage?: Host.AidaClient.AidaInferenceLanguage): void {
+    this.#debouncedRequestAidaSuggestion(prefix, suffix, cursorPositionAtRequest, inferenceLanguage);
   }
 
   remove(): void {

package/front_end/models/badges/UserBadges.ts

@@ -22,6 +22,9 @@ export interface EventTypes {
   [Events.BADGE_TRIGGERED]: Badge;
 }
 
+const SNOOZE_TIME_MS = 24 * 60 * 60 * 1000;  // 24 hours
+const MAX_SNOOZE_COUNT = 3;
+
 let userBadgesInstance: UserBadges|undefined = undefined;
 export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly #badgeActionEventTarget = new Common.ObjectWrapper.ObjectWrapper<BadgeActionEvents>();
@@ -29,6 +32,10 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   #receiveBadgesSetting: Common.Settings.Setting<Boolean>;
   #allBadges: Badge[];
 
+  #starterBadgeSnoozeCount: Common.Settings.Setting<number>;
+  #starterBadgeLastSnoozedTimestamp: Common.Settings.Setting<number>;
+  #starterBadgeDismissed: Common.Settings.Setting<boolean>;
+
   static readonly BADGE_REGISTRY: BadgeClass[] = [
     StarterBadge,
     SpeedsterBadge,
@@ -43,6 +50,13 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     this.#receiveBadgesSetting = Common.Settings.Settings.instance().moduleSetting('receive-gdp-badges');
     this.#receiveBadgesSetting.addChangeListener(this.#reconcileBadges, this);
 
+    this.#starterBadgeSnoozeCount = Common.Settings.Settings.instance().createSetting(
+        'starter-badge-snooze-count', 0, Common.Settings.SettingStorageType.SYNCED);
+    this.#starterBadgeLastSnoozedTimestamp = Common.Settings.Settings.instance().createSetting(
+        'starter-badge-last-snoozed-timestamp', 0, Common.Settings.SettingStorageType.SYNCED);
+    this.#starterBadgeDismissed = Common.Settings.Settings.instance().createSetting(
+        'starter-badge-dismissed', false, Common.Settings.SettingStorageType.SYNCED);
+
     this.#allBadges = UserBadges.BADGE_REGISTRY.map(badgeCtor => new badgeCtor({
                                                       onTriggerBadge: this.#onTriggerBadge.bind(this),
                                                       badgeActionEventTarget: this.#badgeActionEventTarget,
@@ -60,6 +74,15 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     return await this.#reconcileBadges();
   }
 
+  snoozeStarterBadge(): void {
+    this.#starterBadgeSnoozeCount.set(this.#starterBadgeSnoozeCount.get() + 1);
+    this.#starterBadgeLastSnoozedTimestamp.set(Date.now());
+  }
+
+  dismissStarterBadge(): void {
+    this.#starterBadgeDismissed.set(true);
+  }
+
   recordAction(action: BadgeAction): void {
     // `Common.ObjectWrapper.ObjectWrapper` does not allow passing unions to
     // the `dispatchEventToListeners` and `action` in this case is a union.
@@ -79,7 +102,8 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
       const gdpProfile = await Host.GdpClient.GdpClient.instance().getProfile();
       const receiveBadgesSettingEnabled = Boolean(this.#receiveBadgesSetting.get());
       // If there is a GDP profile and the user has enabled receiving badges, we award the starter badge as well.
-      if (gdpProfile && receiveBadgesSettingEnabled) {
+      if (gdpProfile && receiveBadgesSettingEnabled && !this.#isStarterBadgeDismissed() &&
+          !this.#isStarterBadgeSnoozed()) {
         shouldAwardBadge = true;
       }
     }
@@ -101,7 +125,17 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
     });
   }
 
-  // TODO(ergunsh): Implement starter badge dismissal, snooze count & timestamp checks.
+  #isStarterBadgeDismissed(): boolean {
+    return this.#starterBadgeDismissed.get();
+  }
+
+  #isStarterBadgeSnoozed(): boolean {
+    const snoozeCount = this.#starterBadgeSnoozeCount.get();
+    const lastSnoozed = this.#starterBadgeLastSnoozedTimestamp.get();
+    const snoozedRecently = (Date.now() - lastSnoozed) < SNOOZE_TIME_MS;
+    return snoozeCount >= MAX_SNOOZE_COUNT || snoozedRecently;
+  }
+
   async #reconcileBadges(): Promise<void> {
     const syncInfo = await new Promise<Host.InspectorFrontendHostAPI.SyncInformation>(
         resolve => Host.InspectorFrontendHost.InspectorFrontendHostInstance.getSyncInformation(resolve));
@@ -148,7 +182,8 @@ export class UserBadges extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
         continue;
       }
 
-      const shouldActivateStarterBadge = badge.isStarterBadge && isEligibleToCreateProfile;
+      const shouldActivateStarterBadge = badge.isStarterBadge && isEligibleToCreateProfile &&
+          !this.#isStarterBadgeDismissed() && !this.#isStarterBadgeSnoozed();
       const shouldActivateActivityBasedBadge =
           !badge.isStarterBadge && Boolean(gdpProfile) && receiveBadgesSettingEnabled;
       if (shouldActivateStarterBadge || shouldActivateActivityBasedBadge) {

package/front_end/models/bindings/ContentProviderBasedProject.ts

@@ -126,9 +126,9 @@ export class ContentProviderBasedProject extends Workspace.Workspace.ProjectStor
       progress: Common.Progress.Progress):
       Promise<Map<Workspace.UISourceCode.UISourceCode, TextUtils.ContentProvider.SearchMatch[]|null>> {
     const result = new Map();
-    progress.setTotalWork(filesMatchingFileQuery.length);
+    progress.totalWork = filesMatchingFileQuery.length;
     await Promise.all(filesMatchingFileQuery.map(searchInContent.bind(this)));
-    progress.done();
+    progress.done = true;
     return result;
 
     async function searchInContent(
@@ -148,12 +148,14 @@ export class ContentProviderBasedProject extends Workspace.Workspace.ProjectStor
       if (allMatchesFound) {
         result.set(uiSourceCode, matches);
       }
-      progress.incrementWorked(1);
+      ++progress.worked;
     }
   }
 
   override indexContent(progress: Common.Progress.Progress): void {
-    queueMicrotask(progress.done.bind(progress));
+    queueMicrotask(() => {
+      progress.done = true;
+    });
   }
 
   addUISourceCodeWithProvider(

package/front_end/models/breakpoints/BreakpointManager.ts

@@ -272,7 +272,7 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
       if (!BreakpointManager.isValidPositionInScript(lineNumber, columnNumber, script)) {
         continue;
       }
-      this.innerSetBreakpoint(
+      this.#setBreakpoint(
           uiSourceCode, lineNumber, columnNumber, breakpoint.condition, breakpoint.enabled, breakpoint.isLogpoint,
           BreakpointOrigin.OTHER);
     }
@@ -316,7 +316,7 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
       const normalizedLocation = await this.debuggerWorkspaceBinding.normalizeUILocation(uiLocation);
       const breakpointLocation = BreakpointManager.breakpointLocationFromUiLocation(normalizedLocation);
 
-      const breakpoint = this.innerSetBreakpoint(
+      const breakpoint = this.#setBreakpoint(
           normalizedLocation.uiSourceCode, breakpointLocation.lineNumber, breakpointLocation.columnNumber, condition,
           enabled, isLogpoint, origin);
 
@@ -333,7 +333,7 @@ export class BreakpointManager extends Common.ObjectWrapper.ObjectWrapper<EventT
     return primaryBreakpoint;
   }
 
-  private innerSetBreakpoint(
+  #setBreakpoint(
       uiSourceCode: Workspace.UISourceCode.UISourceCode, lineNumber: number, columnNumber: number|undefined,
       condition: UserCondition, enabled: boolean, isLogpoint: boolean, origin: BreakpointOrigin): Breakpoint {
     const url = BreakpointManager.getScriptForInlineUiSourceCode(uiSourceCode)?.sourceURL ?? uiSourceCode.url();

package/front_end/models/formatter/FormatterWorkerPool.ts

@@ -7,8 +7,6 @@ import * as FormatterActions from '../../entrypoints/formatter_worker/FormatterA
 
 export {DefinitionKind, type ScopeTreeNode} from '../../entrypoints/formatter_worker/FormatterActions.js';
 
-const MAX_WORKERS = Math.max(2, navigator.hardwareConcurrency - 1);
-
 let formatterWorkerPoolInstance: FormatterWorkerPool;
 
 export class FormatterWorkerPool {
@@ -37,12 +35,14 @@ export class FormatterWorkerPool {
   }
 
   private processNextTask(): void {
+    const maxWorkers = Math.max(2, navigator.hardwareConcurrency - 1);
+
     if (!this.taskQueue.length) {
       return;
     }
 
     let freeWorker = [...this.workerTasks.keys()].find(worker => !this.workerTasks.get(worker));
-    if (!freeWorker && this.workerTasks.size < MAX_WORKERS) {
+    if (!freeWorker && this.workerTasks.size < maxWorkers) {
       freeWorker = this.createWorker();
     }
     if (!freeWorker) {

package/front_end/models/har/Writer.ts

@@ -59,7 +59,7 @@ export class Writer {
     const compositeProgress = new Common.Progress.CompositeProgress(progress);
 
     const content = await Writer.harStringForRequests(requests, options, compositeProgress);
-    if (progress.isCanceled()) {
+    if (progress.canceled) {
       return;
     }
     await Writer.writeToStream(stream, compositeProgress, content);
@@ -69,8 +69,8 @@ export class Writer {
       requests: SDK.NetworkRequest.NetworkRequest[], options: BuildOptions,
       compositeProgress: Common.Progress.CompositeProgress): Promise<string> {
     const progress = compositeProgress.createSubProgress();
-    progress.setTitle(i18nString(UIStrings.collectingContent));
-    progress.setTotalWork(requests.length);
+    progress.title = i18nString(UIStrings.collectingContent);
+    progress.totalWork = requests.length;
 
     // Sort by issueTime because this is recorded as startedDateTime in HAR logs.
     requests.sort((reqA, reqB) => reqA.issueTime() - reqB.issueTime());
@@ -82,9 +82,9 @@ export class Writer {
     }
 
     await Promise.all(promises);
-    progress.done();
+    progress.done = true;
 
-    if (progress.isCanceled()) {
+    if (progress.canceled) {
       return '';
     }
     return JSON.stringify({log: harLog}, null, jsonIndent);
@@ -106,7 +106,7 @@ export class Writer {
     }
 
     function contentLoaded(entry: EntryDTO, contentDataOrError: TextUtils.ContentData.ContentDataOrError): void {
-      progress.incrementWorked();
+      ++progress.worked;
       const contentData = TextUtils.ContentData.ContentData.asDeferredContent(contentDataOrError);
       let encoded: true|boolean = contentData.isEncoded;
       if (contentData.content !== null) {
@@ -127,14 +127,14 @@ export class Writer {
       stream: Common.StringOutputStream.OutputStream, compositeProgress: Common.Progress.CompositeProgress,
       fileContent: string): Promise<void> {
     const progress = compositeProgress.createSubProgress();
-    progress.setTitle(i18nString(UIStrings.writingFile));
-    progress.setTotalWork(fileContent.length);
-    for (let i = 0; i < fileContent.length && !progress.isCanceled(); i += chunkSize) {
+    progress.title = i18nString(UIStrings.writingFile);
+    progress.totalWork = fileContent.length;
+    for (let i = 0; i < fileContent.length && !progress.canceled; i += chunkSize) {
       const chunk = fileContent.substr(i, chunkSize);
       await stream.write(chunk);
-      progress.incrementWorked(chunk.length);
+      progress.worked += chunk.length;
     }
-    progress.done();
+    progress.done = true;
   }
 }
 

package/front_end/models/persistence/FileSystemWorkspaceBinding.ts

@@ -276,14 +276,14 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
     if (!queriesToRun.length) {
       queriesToRun.push('');
     }
-    progress.setTotalWork(queriesToRun.length);
+    progress.totalWork = queriesToRun.length;
 
     for (const query of queriesToRun) {
       const files = await this.#fileSystem.searchInPath(searchConfig.isRegex() ? '' : query, progress);
       files.sort(Platform.StringUtilities.naturalOrderComparator);
       workingFileSet = Platform.ArrayUtilities.intersectOrdered(
           workingFileSet, files, Platform.StringUtilities.naturalOrderComparator);
-      progress.incrementWorked(1);
+      ++progress.worked;
     }
 
     const result = new Map();
@@ -294,7 +294,7 @@ export class FileSystem extends Workspace.Workspace.ProjectStore {
       }
     }
 
-    progress.done();
+    progress.done = true;
     return result;
   }
 

package/front_end/models/persistence/IsolatedFileSystem.ts

@@ -184,7 +184,7 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     let activePath = '';
     for (const path of paths) {
       activePath = activePath + '/' + path;
-      dirEntry = await this.innerCreateFolderIfNeeded(activePath);
+      dirEntry = await this.#createFolderIfNeeded(activePath);
       if (!dirEntry) {
         return null;
       }
@@ -192,7 +192,7 @@ export class IsolatedFileSystem extends PlatformFileSystem {
     return dirEntry;
   }
 
-  private innerCreateFolderIfNeeded(path: string): Promise<DirectoryEntry|null> {
+  #createFolderIfNeeded(path: string): Promise<DirectoryEntry|null> {
     return new Promise(resolve => {
       this.domFileSystem.root.getDirectory(path, {create: true}, dirEntry => resolve(dirEntry), error => {
         this.domFileSystem.root.getFile(
@@ -517,13 +517,13 @@ export class IsolatedFileSystem extends PlatformFileSystem {
 
       function innerCallback(files: Platform.DevToolsPath.RawPathString[]): void {
         resolve(files.map(path => Common.ParsedURL.ParsedURL.rawPathToUrlString(path)));
-        progress.incrementWorked(1);
+        ++progress.worked;
       }
     });
   }
 
   override indexContent(progress: Common.Progress.Progress): void {
-    progress.setTotalWork(1);
+    progress.totalWork = 1;
     const requestId = this.manager.registerProgress(progress);
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.indexPath(
         requestId, this.#embedderPath, JSON.stringify(this.excludedEmbedderFolders));

package/front_end/models/persistence/IsolatedFileSystemManager.ts

@@ -123,7 +123,7 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
       const fileSystems = event.data;
       const promises = [];
       for (let i = 0; i < fileSystems.length; ++i) {
-        promises.push(this.innerAddFileSystem(fileSystems[i], false));
+        promises.push(this.#addFileSystem(fileSystems[i], false));
       }
       void Promise.all(promises).then(onFileSystemsAdded);
     }
@@ -154,7 +154,7 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
     return this.fileSystemsLoadedPromise;
   }
 
-  private innerAddFileSystem(fileSystem: Host.InspectorFrontendHostAPI.DevToolsFileSystem, dispatchEvent: boolean):
+  #addFileSystem(fileSystem: Host.InspectorFrontendHostAPI.DevToolsFileSystem, dispatchEvent: boolean):
       Promise<IsolatedFileSystem|null> {
     const embedderPath = fileSystem.fileSystemPath;
     const fileSystemURL = Common.ParsedURL.ParsedURL.rawPathToUrlString(fileSystem.fileSystemPath);
@@ -196,7 +196,7 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
       this.fileSystemRequestResolve.call(null, null);
       this.fileSystemRequestResolve = null;
     } else if (fileSystem) {
-      void this.innerAddFileSystem(fileSystem, true).then(fileSystem => {
+      void this.#addFileSystem(fileSystem, true).then(fileSystem => {
         if (this.fileSystemRequestResolve) {
           this.fileSystemRequestResolve.call(null, fileSystem);
           this.fileSystemRequestResolve = null;
@@ -287,7 +287,7 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
     if (!progress) {
       return;
     }
-    progress.setTotalWork(totalWork);
+    progress.totalWork = totalWork;
   }
 
   private onIndexingWorked(
@@ -297,8 +297,8 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
     if (!progress) {
       return;
     }
-    progress.incrementWorked(worked);
-    if (progress.isCanceled()) {
+    progress.worked += worked;
+    if (progress.canceled) {
       Host.InspectorFrontendHost.InspectorFrontendHostInstance.stopIndexing(requestId);
       this.onIndexingDone(event);
     }
@@ -311,7 +311,7 @@ export class IsolatedFileSystemManager extends Common.ObjectWrapper.ObjectWrappe
     if (!progress) {
       return;
     }
-    progress.done();
+    progress.done = true;
     this.progresses.delete(requestId);
   }
 

package/front_end/models/persistence/PersistenceImpl.ts

@@ -64,19 +64,19 @@ export class PersistenceImpl extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   }
 
   async addBinding(binding: PersistenceBinding): Promise<void> {
-    await this.innerAddBinding(binding);
+    await this.#addBinding(binding);
   }
 
   async addBindingForTest(binding: PersistenceBinding): Promise<void> {
-    await this.innerAddBinding(binding);
+    await this.#addBinding(binding);
   }
 
   async removeBinding(binding: PersistenceBinding): Promise<void> {
-    await this.innerRemoveBinding(binding);
+    await this.#removeBinding(binding);
   }
 
   async removeBindingForTest(binding: PersistenceBinding): Promise<void> {
-    await this.innerRemoveBinding(binding);
+    await this.#removeBinding(binding);
   }
 
   #setupBindings(networkUISourceCode: Workspace.UISourceCode.UISourceCode): Promise<void> {
@@ -86,7 +86,7 @@ export class PersistenceImpl extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     return this.#mapping.computeNetworkStatus(networkUISourceCode);
   }
 
-  private async innerAddBinding(binding: PersistenceBinding): Promise<void> {
+  async #addBinding(binding: PersistenceBinding): Promise<void> {
     bindings.set(binding.network, binding);
     bindings.set(binding.fileSystem, binding);
 
@@ -119,7 +119,7 @@ export class PersistenceImpl extends Common.ObjectWrapper.ObjectWrapper<EventTyp
     this.dispatchEventToListeners(Events.BindingCreated, binding);
   }
 
-  private async innerRemoveBinding(binding: PersistenceBinding): Promise<void> {
+  async #removeBinding(binding: PersistenceBinding): Promise<void> {
     if (bindings.get(binding.network) !== binding) {
       return;
     }
@@ -150,12 +150,12 @@ export class PersistenceImpl extends Common.ObjectWrapper.ObjectWrapper<EventTyp
   private onStatusAdded(status: AutomappingStatus): Promise<void> {
     const binding = new PersistenceBinding(status.network, status.fileSystem);
     statusBindings.set(status, binding);
-    return this.innerAddBinding(binding);
+    return this.#addBinding(binding);
   }
 
   private async onStatusRemoved(status: AutomappingStatus): Promise<void> {
     const binding = statusBindings.get(status) as PersistenceBinding;
-    await this.innerRemoveBinding(binding);
+    await this.#removeBinding(binding);
   }
 
   private onWorkingCopyChanged(event: Common.EventTarget.EventTargetEvent<Workspace.UISourceCode.UISourceCode>): void {

package/front_end/models/persistence/PlatformFileSystem.ts

@@ -148,7 +148,7 @@ export class PlatformFileSystem extends Common.ObjectWrapper.ObjectWrapper<Event
 
   indexContent(progress: Common.Progress.Progress): void {
     queueMicrotask(() => {
-      progress.done();
+      progress.done = true;
     });
   }
 

package/front_end/models/trace/ModelImpl.ts

@@ -14,12 +14,6 @@ import * as Types from './types/types.js';
 // processors. Currently there is only one implemented, but you will see
 // references to "processors" plural because it can easily be extended in the future.
 
-export interface ParseConfig {
-  metadata?: Types.File.MetaData;
-  isFreshRecording?: boolean;
-  resolveSourceMap?: Types.Configuration.ParseOptions['resolveSourceMap'];
-}
-
 /**
  * The Model is responsible for parsing arrays of raw trace events and storing the
  * resulting data. It can store multiple traces at once, and can return the data for
@@ -87,10 +81,8 @@ export class Model extends EventTarget {
    * });
    * void this.traceModel.parse(events);
    **/
-  async parse(traceEvents: readonly Types.Events.Event[], config?: ParseConfig): Promise<void> {
+  async parse(traceEvents: readonly Types.Events.Event[], config?: Types.Configuration.ParseOptions): Promise<void> {
     const metadata = config?.metadata || {};
-    const isFreshRecording = config?.isFreshRecording || false;
-    const isCPUProfile = metadata?.dataOrigin === Types.File.DataOrigin.CPU_PROFILE;
     // During parsing, periodically update any listeners on each processors'
     // progress (if they have any updates).
     const onTraceUpdate = (event: Event): void => {
@@ -106,13 +98,7 @@ export class Model extends EventTarget {
     try {
       // Wait for all outstanding promises before finishing the async execution,
       // but perform all tasks in parallel.
-      const parseConfig: Types.Configuration.ParseOptions = {
-        isFreshRecording,
-        isCPUProfile,
-        metadata,
-        resolveSourceMap: config?.resolveSourceMap,
-      };
-      await this.#processor.parse(traceEvents, parseConfig);
+      await this.#processor.parse(traceEvents, config ?? {});
       if (!this.#processor.data) {
         throw new Error('processor did not parse trace');
       }

package/front_end/models/trace/Processor.ts

@@ -152,6 +152,10 @@ export class TraceProcessor extends EventTarget {
       throw new Error(`Trace processor can't start parsing when not idle. Current state: ${this.#status}`);
     }
 
+    if (typeof options.isCPUProfile === 'undefined' && options.metadata) {
+      options.isCPUProfile = options.metadata.dataOrigin === Types.File.DataOrigin.CPU_PROFILE;
+    }
+
     options.logger?.start('total');
     try {
       this.#status = Status.PARSING;
@@ -424,9 +428,9 @@ export class TraceProcessor extends EventTarget {
     insightSet.model = newModel;
   }
 
-  #computeInsightSet(
-      data: Handlers.Types.HandlerData, context: Insights.Types.InsightSetContext,
-      options: Types.Configuration.ParseOptions): void {
+  #computeInsightSet(data: Handlers.Types.HandlerData, context: Insights.Types.InsightSetContext): void {
+    const logger = context.options.logger;
+
     let id, urlString, navigation;
     if (context.navigation) {
       id = context.navigationId;
@@ -442,8 +446,8 @@ export class TraceProcessor extends EventTarget {
     for (const [name, insight] of Object.entries(TraceProcessor.getInsightRunners())) {
       let model: Insights.Types.InsightModel|Error;
       try {
-        options.logger?.start(`insights:${name}`);
-        model = insight.generateInsight(data, context, options.insightTimeFormatters);
+        logger?.start(`insights:${name}`);
+        model = insight.generateInsight(data, context);
         model.frameId = context.frameId;
         const navId = context.navigation?.args.data?.navigationId;
         if (navId) {
@@ -456,7 +460,7 @@ export class TraceProcessor extends EventTarget {
       } catch (err) {
         model = err;
       } finally {
-        options.logger?.end(`insights:${name}`);
+        logger?.end(`insights:${name}`);
       }
       Object.assign(insightSetModel, {[name]: model});
     }
@@ -503,7 +507,7 @@ export class TraceProcessor extends EventTarget {
       this.#insights = new Map();
     }
     this.#insights.set(insightSet.id, insightSet);
-    this.sortInsightSet(insightSet, options.metadata ?? null);
+    this.sortInsightSet(insightSet, context.options.metadata ?? null);
   }
 
   /**
@@ -543,11 +547,12 @@ export class TraceProcessor extends EventTarget {
         data.Meta.traceBounds;
 
     const context: Insights.Types.InsightSetContext = {
+      options,
       bounds,
       frameId: data.Meta.mainFrameId,
       // No navigation or lantern context applies to this initial/no-navigation period.
     };
-    this.#computeInsightSet(data, context, options);
+    this.#computeInsightSet(data, context);
   }
 
   /**
@@ -593,13 +598,14 @@ export class TraceProcessor extends EventTarget {
     }
 
     const context: Insights.Types.InsightSetContext = {
+      options,
       bounds,
       frameId,
       navigation,
       navigationId,
       lantern,
     };
-    this.#computeInsightSet(data, context, options);
+    this.#computeInsightSet(data, context);
   }
 }
 

package/front_end/models/trace/handlers/AuctionWorkletsHandler.ts

@@ -93,9 +93,9 @@ function workletType(input: string): Types.Events.AuctionWorkletType {
  * create everything other than the `args` field, as those are identical
  * regardless of the type of event.
  */
-function makeSyntheticEventBase(event: Types.Events.AuctionWorkletDoneWithProcess|
-                                Types.Events.AuctionWorkletRunningInProcess):
-    Omit<Types.Events.SyntheticAuctionWorklet, 'args'> {
+function makeSyntheticEventBase(
+    event: Types.Events.AuctionWorkletDoneWithProcess|
+    Types.Events.AuctionWorkletRunningInProcess): Omit<Types.Events.SyntheticAuctionWorklet, 'args'> {
   return Helpers.SyntheticEvents.SyntheticEventsManager
       .registerSyntheticEvent<Omit<Types.Events.SyntheticAuctionWorklet, 'args'>>({
         rawSourceEvent: event,
@@ -178,6 +178,6 @@ export interface AuctionWorkletsData {
 
 export function data(): AuctionWorkletsData {
   return {
-    worklets: new Map(createdSyntheticEvents),
+    worklets: createdSyntheticEvents,
   };
 }

package/front_end/models/trace/handlers/FramesHandler.ts

@@ -95,8 +95,8 @@ export interface FramesData {
 
 export function data(): FramesData {
   return {
-    frames: model ? Array.from(model.frames()) : [],
-    framesById: model ? {...model.framesById()} : {},
+    frames: model?.frames() ?? [],
+    framesById: model?.framesById() ?? {},
   };
 }