chrome-devtools-frontend 1.0.1515446 → 1.0.1515988

package/front_end/models/ai_assistance/data_formatters/PerformanceTraceFormatter.ts

@@ -31,6 +31,81 @@ export class PerformanceTraceFormatter {
     return `{min: ${bounds.min}, max: ${bounds.max}}`;
   }
 
+  /**
+   * Fetching the Crux summary can error outside of DevTools, hence the
+   * try-catch around it here.
+   */
+  #getCruxTraceSummary(insightSet: Trace.Insights.Types.InsightSet|null): string[] {
+    if (insightSet === null) {
+      return [];
+    }
+    try {
+      const cruxScope = CrUXManager.CrUXManager.instance().getSelectedScope();
+      const parts: string[] = [];
+      const fieldMetrics =
+          Trace.Insights.Common.getFieldMetricsForInsightSet(insightSet, this.#parsedTrace.metadata, cruxScope);
+      const fieldLcp = fieldMetrics?.lcp;
+      const fieldInp = fieldMetrics?.inp;
+      const fieldCls = fieldMetrics?.cls;
+
+      if (fieldLcp || fieldInp || fieldCls) {
+        parts.push('Metrics (field / real users):');
+
+        const serializeFieldMetricTimingResult =
+            (fieldMetric: Trace.Insights.Common.CrUXFieldMetricTimingResult): string => {
+              return `${Math.round(fieldMetric.value / 1000)} ms (scope: ${fieldMetric.pageScope})`;
+            };
+
+        const serializeFieldMetricNumberResult =
+            (fieldMetric: Trace.Insights.Common.CrUXFieldMetricNumberResult): string => {
+              return `${fieldMetric.value.toFixed(2)} (scope: ${fieldMetric.pageScope})`;
+            };
+
+        if (fieldLcp) {
+          parts.push(`  - LCP: ${serializeFieldMetricTimingResult(fieldLcp)}`);
+
+          const fieldLcpBreakdown = fieldMetrics?.lcpBreakdown;
+          if (fieldLcpBreakdown &&
+              (fieldLcpBreakdown.ttfb || fieldLcpBreakdown.loadDelay || fieldLcpBreakdown.loadDuration ||
+               fieldLcpBreakdown.renderDelay)) {
+            parts.push('  - LCP breakdown:');
+            if (fieldLcpBreakdown.ttfb) {
+              parts.push(`    - TTFB: ${serializeFieldMetricTimingResult(fieldLcpBreakdown.ttfb)}`);
+            }
+            if (fieldLcpBreakdown.loadDelay) {
+              parts.push(`    - Load delay: ${serializeFieldMetricTimingResult(fieldLcpBreakdown.loadDelay)}`);
+            }
+            if (fieldLcpBreakdown.loadDuration) {
+              parts.push(`    - Load duration: ${serializeFieldMetricTimingResult(fieldLcpBreakdown.loadDuration)}`);
+            }
+            if (fieldLcpBreakdown.renderDelay) {
+              parts.push(`    - Render delay: ${serializeFieldMetricTimingResult(fieldLcpBreakdown.renderDelay)}`);
+            }
+          }
+        }
+        if (fieldInp) {
+          parts.push(`  - INP: ${serializeFieldMetricTimingResult(fieldInp)}`);
+        }
+        if (fieldCls) {
+          parts.push(`  - CLS: ${serializeFieldMetricNumberResult(fieldCls)}`);
+        }
+
+        parts.push(
+            '  - The above data is from CrUX–Chrome User Experience Report. It\'s how the page performs for real users.');
+        parts.push('  - The values shown above are the p75 measure of all real Chrome users');
+        parts.push('  - The scope indicates if the data came from the entire origin, or a specific url');
+        parts.push(
+            '  - Lab metrics describe how this specific page load performed, while field metrics are an aggregation ' +
+            'of results from real-world users. Best practice is to prioritize metrics that are bad in field data. ' +
+            'Lab metrics may be better or worse than fields metrics depending on the developer\'s machine, network, or the ' +
+            'actions performed while tracing.');
+      }
+      return parts;
+    } catch {
+      return [];
+    }
+  }
+
   formatTraceSummary(): string {
     const parsedTrace = this.#parsedTrace;
     const insightSet = this.#insightSet;
@@ -78,64 +153,9 @@ export class PerformanceTraceFormatter {
       parts.push('Metrics (lab / observed): n/a');
     }
 
-    const fieldMetrics = insightSet &&
-        Trace.Insights.Common.getFieldMetricsForInsightSet(
-            insightSet, traceMetadata, CrUXManager.CrUXManager.instance().getSelectedScope());
-    const fieldLcp = fieldMetrics?.lcp;
-    const fieldInp = fieldMetrics?.inp;
-    const fieldCls = fieldMetrics?.cls;
-
-    if (fieldLcp || fieldInp || fieldCls) {
-      parts.push('Metrics (field / real users):');
-
-      const serializeFieldMetricTimingResult =
-          (fieldMetric: Trace.Insights.Common.CrUXFieldMetricTimingResult): string => {
-            return `${Math.round(fieldMetric.value / 1000)} ms (scope: ${fieldMetric.pageScope})`;
-          };
-
-      const serializeFieldMetricNumberResult =
-          (fieldMetric: Trace.Insights.Common.CrUXFieldMetricNumberResult): string => {
-            return `${fieldMetric.value.toFixed(2)} (scope: ${fieldMetric.pageScope})`;
-          };
-
-      if (fieldLcp) {
-        parts.push(`  - LCP: ${serializeFieldMetricTimingResult(fieldLcp)}`);
-
-        const fieldLcpBreakdown = fieldMetrics?.lcpBreakdown;
-        if (fieldLcpBreakdown &&
-            (fieldLcpBreakdown.ttfb || fieldLcpBreakdown.loadDelay || fieldLcpBreakdown.loadDuration ||
-             fieldLcpBreakdown.renderDelay)) {
-          parts.push('  - LCP breakdown:');
-          if (fieldLcpBreakdown.ttfb) {
-            parts.push(`    - TTFB: ${serializeFieldMetricTimingResult(fieldLcpBreakdown.ttfb)}`);
-          }
-          if (fieldLcpBreakdown.loadDelay) {
-            parts.push(`    - Load delay: ${serializeFieldMetricTimingResult(fieldLcpBreakdown.loadDelay)}`);
-          }
-          if (fieldLcpBreakdown.loadDuration) {
-            parts.push(`    - Load duration: ${serializeFieldMetricTimingResult(fieldLcpBreakdown.loadDuration)}`);
-          }
-          if (fieldLcpBreakdown.renderDelay) {
-            parts.push(`    - Render delay: ${serializeFieldMetricTimingResult(fieldLcpBreakdown.renderDelay)}`);
-          }
-        }
-      }
-      if (fieldInp) {
-        parts.push(`  - INP: ${serializeFieldMetricTimingResult(fieldInp)}`);
-      }
-      if (fieldCls) {
-        parts.push(`  - CLS: ${serializeFieldMetricNumberResult(fieldCls)}`);
-      }
-
-      parts.push(
-          '  - The above data is from CrUX–Chrome User Experience Report. It\'s how the page performs for real users.');
-      parts.push('  - The values shown above are the p75 measure of all real Chrome users');
-      parts.push('  - The scope indicates if the data came from the entire origin, or a specific url');
-      parts.push(
-          '  - Lab metrics describe how this specific page load performed, while field metrics are an aggregation ' +
-          'of results from real-world users. Best practice is to prioritize metrics that are bad in field data. ' +
-          'Lab metrics may be better or worse than fields metrics depending on the developer\'s machine, network, or the ' +
-          'actions performed while tracing.');
+    const cruxParts = insightSet && this.#getCruxTraceSummary(insightSet);
+    if (cruxParts?.length) {
+      parts.push(...cruxParts);
     } else {
       parts.push('Metrics (field / real users): n/a – no data for this page in CrUX');
     }

package/front_end/models/ai_assistance/data_formatters/UnitFormatters.ts

@@ -10,7 +10,7 @@ const defaultTimeFormatterOptions: Intl.NumberFormatOptions = {
   style: 'unit',
   unitDisplay: 'narrow',
   minimumFractionDigits: 0,
-  maximumFractionDigits: 1,
+  maximumFractionDigits: 0,
 } as const;
 
 const defaultByteFormatterOptions: Intl.NumberFormatOptions = {
@@ -25,8 +25,14 @@ const timeFormatters = {
     ...defaultTimeFormatterOptions,
     unit: 'millisecond',
   }),
+  milliWithPrecision: new Intl.NumberFormat('en-US', {
+    ...defaultTimeFormatterOptions,
+    maximumFractionDigits: 1,
+    unit: 'millisecond',
+  }),
   second: new Intl.NumberFormat('en-US', {
     ...defaultTimeFormatterOptions,
+    maximumFractionDigits: 1,
     unit: 'second',
   }),
   micro: new Intl.NumberFormat('en-US', {
@@ -81,6 +87,9 @@ export function millis(x: number): string {
   if (numberIsTooLarge(x)) {
     return '-';
   }
+  if (x < 1) {
+    return formatAndEnsureSpace(timeFormatters.milliWithPrecision, x);
+  }
   return formatAndEnsureSpace(timeFormatters.milli, x);
 }
 

package/front_end/models/ai_assistance/performance/AIContext.ts

@@ -6,28 +6,13 @@ import * as Trace from '../../../models/trace/trace.js';
 
 import type {AICallTree} from './AICallTree.js';
 
-export interface AgentFocusDataFull {
-  type: 'full';
+export interface AgentFocusData {
   parsedTrace: Trace.TraceModel.ParsedTrace;
   insightSet: Trace.Insights.Types.InsightSet|null;
+  callTree: AICallTree|null;
+  insight: Trace.Insights.Types.InsightModel|null;
 }
 
-interface AgentFocusDataCallTree {
-  type: 'call-tree';
-  parsedTrace: Trace.TraceModel.ParsedTrace;
-  insightSet: Trace.Insights.Types.InsightSet|null;
-  callTree: AICallTree;
-}
-
-export interface AgentFocusDataInsight {
-  type: 'insight';
-  parsedTrace: Trace.TraceModel.ParsedTrace;
-  insightSet: Trace.Insights.Types.InsightSet|null;
-  insight: Trace.Insights.Types.InsightModel;
-}
-
-type AgentFocusData = AgentFocusDataCallTree|AgentFocusDataInsight|AgentFocusDataFull;
-
 function getFirstInsightSet(insights: Trace.Insights.Types.TraceInsightSets): Trace.Insights.Types.InsightSet|null {
   // Currently only support a single insight set. Pick the first one with a navigation.
   // TODO(cjamcl): we should just give the agent the entire insight set, and give
@@ -43,9 +28,10 @@ export class AgentFocus {
 
     const insightSet = getFirstInsightSet(parsedTrace.insights);
     return new AgentFocus({
-      type: 'full',
       parsedTrace,
       insightSet,
+      callTree: null,
+      insight: null,
     });
   }
 
@@ -57,9 +43,9 @@ export class AgentFocus {
 
     const insightSet = getFirstInsightSet(parsedTrace.insights);
     return new AgentFocus({
-      type: 'insight',
       parsedTrace,
       insightSet,
+      callTree: null,
       insight,
     });
   }
@@ -79,7 +65,7 @@ export class AgentFocus {
           getFirstInsightSet(insights);
     }
 
-    return new AgentFocus({type: 'call-tree', parsedTrace: callTree.parsedTrace, insightSet, callTree});
+    return new AgentFocus({parsedTrace: callTree.parsedTrace, insightSet, callTree, insight: null});
   }
 
   #data: AgentFocusData;
@@ -91,6 +77,18 @@ export class AgentFocus {
   get data(): AgentFocusData {
     return this.#data;
   }
+
+  withInsight(insight: Trace.Insights.Types.InsightModel|null): AgentFocus {
+    const focus = new AgentFocus(this.#data);
+    focus.#data.insight = insight;
+    return focus;
+  }
+
+  withCallTree(callTree: AICallTree|null): AgentFocus {
+    const focus = new AgentFocus(this.#data);
+    focus.#data.callTree = callTree;
+    return focus;
+  }
 }
 
 export function getPerformanceAgentFocusFromModel(model: Trace.TraceModel.Model): AgentFocus|null {

package/front_end/models/ai_code_completion/AiCodeCompletion.ts

@@ -202,70 +202,133 @@ export class AiCodeCompletion extends Common.ObjectWrapper.ObjectWrapper<EventTy
     };
   }
 
+  async #completeCodeCached(request: Host.AidaClient.CompletionRequest): Promise<{
+    response: Host.AidaClient.CompletionResponse | null,
+    fromCache: boolean,
+  }> {
+    const cachedResponse = this.#checkCachedRequestForResponse(request);
+    if (cachedResponse) {
+      return {response: cachedResponse, fromCache: true};
+    }
+
+    const response = await this.#aidaClient.completeCode(request);
+    if (!response) {
+      return {
+        response: null,
+        fromCache: false,
+      };
+    }
+
+    this.#updateCachedRequest(request, response);
+    return {
+      response,
+      fromCache: false,
+    };
+  }
+
+  #pickSampleFromResponse(response: Host.AidaClient.CompletionResponse): Host.AidaClient.GenerationSample|null {
+    if (!response.generatedSamples.length) {
+      return null;
+    }
+
+    // `currentHint` is the portion of a standard autocomplete suggestion that the user has not yet typed.
+    // For example, if the user types `document.queryS` and the autocomplete suggests `document.querySelector`,
+    // the `currentHint` is `elector`.
+    const currentHintInMenu = this.#editor.editor.plugin(TextEditor.Config.showCompletionHint)?.currentHint;
+    // TODO(ergunsh): We should not do this check here. Instead, the AI code suggestions should be provided
+    // as it is to the view plugin. The view plugin should choose which one to use based on the completion hint
+    // and selected completion.
+    if (!currentHintInMenu) {
+      return response.generatedSamples[0];
+    }
+
+    // TODO(ergunsh): This does not handle looking for `selectedCompletion`. The `currentHint` is `null`
+    // for the Sources panel case.
+    // Even though there is no match, we still return the first suggestion which will be displayed
+    // when the traditional autocomplete menu is closed.
+    return response.generatedSamples.find(sample => sample.generationString.startsWith(currentHintInMenu)) ??
+        response.generatedSamples[0];
+  }
+
+  async #generateSampleForRequest(request: Host.AidaClient.CompletionRequest, cursor: number): Promise<{
+    suggestionText: string,
+    sampleId: number,
+    fromCache: boolean,
+    citations: Host.AidaClient.Citation[],
+    rpcGlobalId?: Host.AidaClient.RpcGlobalId,
+  }|null> {
+    const {response, fromCache} = await this.#completeCodeCached(request);
+    debugLog('At cursor position', cursor, {request, response, fromCache});
+    if (!response) {
+      return null;
+    }
+
+    const suggestionSample = this.#pickSampleFromResponse(response);
+    if (!suggestionSample) {
+      return null;
+    }
+
+    const shouldBlock =
+        suggestionSample.attributionMetadata?.attributionAction === Host.AidaClient.RecitationAction.BLOCK;
+    if (shouldBlock) {
+      return null;
+    }
+
+    const suggestionText = this.#trimSuggestionOverlap(suggestionSample.generationString, request);
+    if (suggestionText.length === 0) {
+      return null;
+    }
+
+    return {
+      suggestionText,
+      sampleId: suggestionSample.sampleId,
+      fromCache,
+      citations: suggestionSample.attributionMetadata?.citations ?? [],
+      rpcGlobalId: response.metadata.rpcGlobalId,
+    };
+  }
+
   async #requestAidaSuggestion(request: Host.AidaClient.CompletionRequest, cursor: number): Promise<void> {
     const startTime = performance.now();
-    let servedFromCache = false;
     this.dispatchEventToListeners(Events.REQUEST_TRIGGERED, {});
 
     try {
-      let response = this.#checkCachedRequestForResponse(request);
-      if (!response) {
-        response = await this.#aidaClient.completeCode(request);
-        if (response) {
-          this.#updateCachedRequest(request, response);
-        }
-      } else {
-        servedFromCache = true;
+      const sampleResponse = await this.#generateSampleForRequest(request, cursor);
+      if (!sampleResponse) {
+        this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {});
+        return;
       }
-      debugLog('At cursor position', cursor, {request, response});
-      if (response && response.generatedSamples.length > 0 && response.generatedSamples[0].generationString) {
-        if (response.generatedSamples[0].attributionMetadata?.attributionAction ===
-            Host.AidaClient.RecitationAction.BLOCK) {
-          this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {});
-          return;
-        }
 
-        // Use the suffix from the request to find and remove any overlap.
-        let suggestionText = response.generatedSamples[0].generationString;
-        if (request.suffix && request.suffix.length > 0) {
-          suggestionText = this.#trimSuggestionOverlap(response.generatedSamples[0].generationString, request.suffix);
+      const {
+        suggestionText,
+        sampleId,
+        fromCache,
+        citations,
+        rpcGlobalId,
+      } = sampleResponse;
+      const remainingDelay = Math.max(DELAY_BEFORE_SHOWING_RESPONSE_MS - (performance.now() - startTime), 0);
+      this.#renderingTimeout = window.setTimeout(() => {
+        this.#editor.dispatch({
+          effects: TextEditor.Config.setAiAutoCompleteSuggestion.of({
+            text: suggestionText,
+            from: cursor,
+            rpcGlobalId,
+            sampleId,
+          })
+        });
+
+        if (fromCache) {
+          Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeCompletionResponseServedFromCache);
         }
-        if (suggestionText.length === 0) {
-          this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {});
-          return;
+
+        if (rpcGlobalId) {
+          const latency = performance.now() - startTime;
+          this.#registerUserImpression(rpcGlobalId, sampleId, latency);
         }
 
-        const remainderDelay = Math.max(DELAY_BEFORE_SHOWING_RESPONSE_MS - (performance.now() - startTime), 0);
-        // Delays the rendering of the Code completion
-        this.#renderingTimeout = window.setTimeout(() => {
-          // We are not cancelling the previous responses even when there are more recent responses
-          // from the LLM as:
-          // In case the user kept typing characters that are prefix of the previous suggestion, it
-          // is a valid suggestion and we should display it to the user.
-          // In case the user typed a different character, the config for AI auto complete suggestion
-          // will set the suggestion to null.
-          this.#editor.dispatch({
-            effects: TextEditor.Config.setAiAutoCompleteSuggestion.of({
-              text: suggestionText,
-              from: cursor,
-              rpcGlobalId: response.metadata.rpcGlobalId,
-              sampleId: response.generatedSamples[0].sampleId,
-            })
-          });
-          if (servedFromCache) {
-            Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiCodeCompletionResponseServedFromCache);
-          }
-          debugLog('Suggestion dispatched to the editor', response.generatedSamples[0], 'at cursor position', cursor);
-          if (response.metadata.rpcGlobalId) {
-            const latency = performance.now() - startTime;
-            this.#registerUserImpression(response.metadata.rpcGlobalId, response.generatedSamples[0].sampleId, latency);
-          }
-          const citations = response.generatedSamples[0].attributionMetadata?.citations;
-          this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {citations});
-        }, remainderDelay);
-      } else {
-        this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {});
-      }
+        debugLog('Suggestion dispatched to the editor', suggestionText, 'at cursor position', cursor);
+        this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {citations});
+      }, remainingDelay);
     } catch (e) {
       debugLog('Error while fetching code completion suggestions from AIDA', e);
       this.dispatchEventToListeners(Events.RESPONSE_RECEIVED, {});
@@ -289,7 +352,12 @@ export class AiCodeCompletion extends Common.ObjectWrapper.ObjectWrapper<EventTy
   /**
    * Removes the end of a suggestion if it overlaps with the start of the suffix.
    */
-  #trimSuggestionOverlap(generationString: string, suffix: string): string {
+  #trimSuggestionOverlap(generationString: string, request: Host.AidaClient.CompletionRequest): string {
+    const suffix = request.suffix;
+    if (!suffix) {
+      return generationString;
+    }
+
     // Iterate from the longest possible overlap down to the shortest
     for (let i = Math.min(generationString.length, suffix.length); i > 0; i--) {
       const overlapCandidate = suffix.substring(0, i);

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/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/javascript_metadata/NativeFunctions.js

@@ -6088,7 +6088,7 @@ export const NativeFunctions = [
   },
   {
     name: "addAnimation",
-    signatures: [["animation"]]
+    signatures: [["animation","action","behavior"]]
   },
   {
     name: "removeAnimation",
@@ -6765,6 +6765,10 @@ export const NativeFunctions = [
     name: "DragEvent",
     signatures: [["type","?eventInitDict"]]
   },
+  {
+    name: "EmailVerifiedEvent",
+    signatures: [["type","?eventInitDict"]]
+  },
   {
     name: "ErrorEvent",
     signatures: [["type","?eventInitDict"]]
@@ -7605,7 +7609,7 @@ export const NativeFunctions = [
     signatures: [["element","x","y","?dwidth","?dheight"]]
   },
   {
-    name: "drawHTML",
+    name: "drawElementImage",
     signatures: [["element","x","y","?dwidth","?dheight"]]
   },
   {
@@ -8420,10 +8424,6 @@ export const NativeFunctions = [
     name: "RTCRtpScriptTransform",
     signatures: [["worker","?options","?transfer"]]
   },
-  {
-    name: "sendRtp",
-    signatures: [["packet","options"]]
-  },
   {
     name: "setHeaderExtensionsToNegotiate",
     signatures: [["extensions"]]
@@ -8891,7 +8891,7 @@ export const NativeFunctions = [
     signatures: [["provokeMode"]]
   },
   {
-    name: "texHTML2D",
+    name: "texElementImage2D",
     signatures: [["target","level","internalformat","format","type","element"]]
   },
   {

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;
   }