chrome-devtools-frontend 1.0.1668390 → 1.0.1669021

package/front_end/panels/timeline/TimelineLoader.ts

@@ -35,8 +35,8 @@ export class TimelineLoader {
   #collectedEvents: Trace.Types.Events.Event[] = [];
   #metadata: Trace.Types.File.MetaData|null;
 
-  #traceFinalizedCallbackForTest?: () => void;
-  #traceFinalizedPromiseForTest: Promise<void>;
+  #traceLoadedCallback?: (state: LoadingState) => void;
+  #traceLoadedPromise: Promise<LoadingState>;
 
   constructor(client: Client) {
     this.client = client;
@@ -45,8 +45,8 @@ export class TimelineLoader {
     this.#traceIsCPUProfile = false;
     this.#metadata = null;
 
-    this.#traceFinalizedPromiseForTest = new Promise<void>(resolve => {
-      this.#traceFinalizedCallbackForTest = resolve;
+    this.#traceLoadedPromise = new Promise<LoadingState>(resolve => {
+      this.#traceLoadedCallback = resolve;
     });
   }
 
@@ -57,11 +57,10 @@ export class TimelineLoader {
       client.loadingStarted();
       try {
         loader.#processParsedFile(contents);
-        await loader.close();
+        await loader.complete();
       } catch (e: unknown) {
-        await loader.close();
         const message = e instanceof Error ? e.message : '';
-        return loader.reportErrorAndCancelLoading(i18nString(UIStrings.malformedTimelineDataS, {PH1: message}));
+        loader.reportErrorAndCancelLoading(i18nString(UIStrings.malformedTimelineDataS, {PH1: message}));
       }
     });
 
@@ -71,7 +70,11 @@ export class TimelineLoader {
   static loadFromEvents(events: Trace.Types.Events.Event[], client: Client): TimelineLoader {
     const loader = new TimelineLoader(client);
     window.setTimeout(async () => {
-      void loader.addEvents(events, null);
+      try {
+        await loader.addEvents(events, null);
+      } catch (e: unknown) {
+        loader.reportErrorAndCancelLoading(e instanceof Error ? e.message : undefined);
+      }
     });
     return loader;
   }
@@ -79,12 +82,16 @@ export class TimelineLoader {
   static loadFromTraceFile(traceFile: Trace.Types.File.TraceFile, client: Client): TimelineLoader {
     const loader = new TimelineLoader(client);
     window.setTimeout(async () => {
-      void loader.addEvents(traceFile.traceEvents, traceFile.metadata);
+      try {
+        await loader.addEvents(traceFile.traceEvents, traceFile.metadata);
+      } catch (e: unknown) {
+        loader.reportErrorAndCancelLoading(e instanceof Error ? e.message : undefined);
+      }
     });
     return loader;
   }
 
-  static loadFromCpuProfile(profile: Protocol.Profiler.Profile, client: Client): TimelineLoader {
+  static loadFromCpuProfile(profile: Protocol.Profiler.Profile, client: Client, title?: string): TimelineLoader {
     const loader = new TimelineLoader(client);
     loader.#traceIsCPUProfile = true;
 
@@ -93,10 +100,15 @@ export class TimelineLoader {
           profile, Trace.Types.Events.ThreadID(1));
 
       window.setTimeout(async () => {
-        void loader.addEvents(contents.traceEvents, null);
+        try {
+          await loader.addEvents(contents.traceEvents, title ? {title} : null);
+        } catch (e: unknown) {
+          loader.reportErrorAndCancelLoading(e instanceof Error ? e.message : undefined);
+        }
       });
-    } catch (e) {
-      console.error(e.stack);
+    } catch (e: unknown) {
+      console.error(e instanceof Error ? e.stack : e);
+      loader.reportErrorAndCancelLoading(e instanceof Error ? e.message : undefined);
     }
     return loader;
   }
@@ -110,9 +122,8 @@ export class TimelineLoader {
         Common.Settings.Settings.instance().moduleSetting('network.enable-remote-file-loading').get();
     Host.ResourceLoader.loadAsStream(url, null, stream, finishedCallback, allowRemoteFilePaths);
 
-    async function finishedCallback(
-        success: boolean, _headers: Record<string, string>,
-        errorDescription: Host.ResourceLoader.LoadErrorDescription): Promise<void> {
+    async function finishedCallback(success: boolean, _headers: Record<string, string>,
+                                    errorDescription: Host.ResourceLoader.LoadErrorDescription): Promise<void> {
       if (!success) {
         return loader.reportErrorAndCancelLoading(errorDescription.message);
       }
@@ -120,9 +131,8 @@ export class TimelineLoader {
         const txt = stream.data();
         const trace = JSON.parse(txt);
         loader.#processParsedFile(trace);
-        await loader.close();
+        await loader.complete();
       } catch (e: unknown) {
-        await loader.close();
         const message = e instanceof Error ? e.message : '';
         return loader.reportErrorAndCancelLoading(i18nString(UIStrings.malformedTimelineDataS, {PH1: message}));
       }
@@ -166,27 +176,31 @@ export class TimelineLoader {
     }
   }
 
-  async addEvents(events: readonly Trace.Types.Events.Event[], metadata: Trace.Types.File.MetaData|null):
-      Promise<void> {
-    this.#metadata = metadata;
-    this.client?.loadingStarted();
-    /**
-     * See the `eventsPerChunk` comment in `models/trace/types/Configuration.ts`.
-     *
-     * This value is different though. Why? `The addEvents()` work below is different
-     * (and much faster!) than running `handleEvent()` on all handlers.
-     */
-    const eventsPerChunk = 150_000;
-    for (let i = 0; i < events.length; i += eventsPerChunk) {
-      const chunk = events.slice(i, i + eventsPerChunk);
-      this.#collectEvents(chunk as unknown as Trace.Types.Events.Event[]);
-      this.client?.loadingProgress((i + chunk.length) / events.length);
-      await new Promise(r => window.setTimeout(r, 0));  // Yield event loop to paint.
+  async addEvents(events: readonly Trace.Types.Events.Event[],
+                  metadata: Trace.Types.File.MetaData|null): Promise<void> {
+    try {
+      this.#metadata = metadata;
+      this.client?.loadingStarted();
+      /**
+       * See the `eventsPerChunk` comment in `models/trace/types/Configuration.ts`.
+       *
+       * This value is different though. Why? `The addEvents()` work below is different
+       * (and much faster!) than running `handleEvent()` on all handlers.
+       */
+      const eventsPerChunk = 150_000;
+      for (let i = 0; i < events.length; i += eventsPerChunk) {
+        const chunk = events.slice(i, i + eventsPerChunk);
+        this.#collectEvents(chunk as unknown as Trace.Types.Events.Event[]);
+        this.client?.loadingProgress((i + chunk.length) / events.length);
+        await new Promise(r => window.setTimeout(r, 0));  // Yield event loop to paint.
+      }
+      await this.complete();
+    } catch (e: unknown) {
+      this.reportErrorAndCancelLoading(e instanceof Error ? e.message : undefined);
     }
-    void this.close();
   }
 
-  async cancel(): Promise<void> {
+  async #cleanup(): Promise<void> {
     if (this.client) {
       await this.client.loadingComplete(
           /* collectedEvents */[], /* exclusiveFilter= */ null, /* metadata= */ null);
@@ -197,19 +211,29 @@ export class TimelineLoader {
     }
   }
 
+  async cancel(): Promise<void> {
+    await this.#cleanup();
+    this.#traceLoadedCallback?.(LoadingState.CANCELLED);
+  }
+
   private reportErrorAndCancelLoading(message?: string): void {
     if (message) {
       Common.Console.Console.instance().error(message);
     }
-    void this.cancel();
+    this.#traceLoadedCallback?.(LoadingState.ERROR);
+    void this.#cleanup();
   }
 
-  async close(): Promise<void> {
+  async complete(): Promise<void> {
     if (!this.client) {
       return;
     }
     this.client.processingStarted();
-    await this.finalizeTrace();
+    try {
+      await this.finalizeTrace();
+    } catch (e: unknown) {
+      this.reportErrorAndCancelLoading(e instanceof Error ? e.message : undefined);
+    }
   }
 
   private async finalizeTrace(): Promise<void> {
@@ -218,11 +242,11 @@ export class TimelineLoader {
     }
 
     await (this.client as Client).loadingComplete(this.#collectedEvents, this.filter, this.#metadata);
-    this.#traceFinalizedCallbackForTest?.();
+    this.#traceLoadedCallback?.(LoadingState.SUCCESS);
   }
 
-  traceFinalizedForTest(): Promise<void> {
-    return this.#traceFinalizedPromiseForTest;
+  traceLoaded(): Promise<LoadingState> {
+    return this.#traceLoadedPromise;
   }
 
   #parseCPUProfileFormatFromFile(parsedTrace: Protocol.Profiler.Profile): void {
@@ -241,3 +265,9 @@ export class TimelineLoader {
  * Used when we parse the input, but do not yet know if it is a raw CPU Profile or a Trace
  **/
 export type ParsedJSONFile = Trace.Types.File.Contents|Protocol.Profiler.Profile;
+
+export const enum LoadingState {
+  SUCCESS = 'SUCCESS',
+  CANCELLED = 'CANCELLED',
+  ERROR = 'ERROR',
+}

package/front_end/panels/timeline/TimelinePanel.ts

@@ -301,6 +301,16 @@ const UIStrings = {
    * @description Title of the shortcuts dialog shown to the user that lists keyboard shortcuts.
    */
   shortcutsDialogTitle: 'Keyboard shortcuts for flamechart',
+  /**
+   * @description Header for the confirmation dialog asking the user whether
+   * to load a CPU profile recorded by console.profile().
+   */
+  loadCpuProfileHeader: 'Load CPU profile?',
+  /**
+   * @description Confirmation message asking the user whether to load a CPU profile recorded by console.profile().
+   * @example {Profile 1} PH1
+   */
+  loadCpuProfileConfirmation: 'Do you want to load the recorded CPU profile "{PH1}" into the Performance panel?',
 } as const;
 const str_ = i18n.i18n.registerUIStrings('panels/timeline/TimelinePanel.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
@@ -1036,12 +1046,12 @@ export class TimelinePanel extends Common.ObjectWrapper.eventMixin<EventTypes, t
     this.#minimapComponent.highlightBounds(bounds, /* withBracket */ false);
   }
 
-  loadFromCpuProfile(profile: Protocol.Profiler.Profile|null): void {
+  loadFromCpuProfile(profile: Protocol.Profiler.Profile|null, title?: string): void {
     if (this.state !== State.IDLE || profile === null) {
       return;
     }
     this.prepareToLoadTimeline();
-    this.loader = TimelineLoader.loadFromCpuProfile(profile, this);
+    this.loader = TimelineLoader.loadFromCpuProfile(profile, this, title);
   }
 
   private setState(state: State): void {
@@ -3243,9 +3253,24 @@ export class BottomUpProfileRevealer implements Common.Revealer.Revealer<Utils.H
 }
 
 export class ProfileFinishedRevealer implements Common.Revealer.Revealer<SDK.CPUProfilerModel.ProfileFinishedData> {
+  static #consoleProfilePromiseChain: Promise<void> = Promise.resolve();
+
   async reveal(data: SDK.CPUProfilerModel.ProfileFinishedData): Promise<void> {
-    await UI.ViewManager.ViewManager.instance().showView('timeline');
-    TimelinePanel.instance().loadFromCpuProfile(data.cpuProfile);
+    const taskPromise = ProfileFinishedRevealer.#consoleProfilePromiseChain.then(async () => {
+      const title = data.title || 'Untitled';
+      const confirmed = await UI.UIUtils.ConfirmDialog.show(
+          i18nString(UIStrings.loadCpuProfileConfirmation, {PH1: title}),
+          i18nString(UIStrings.loadCpuProfileHeader),
+          undefined,
+          {jslogContext: 'load-cpu-profile-confirmation'},
+      );
+      if (confirmed) {
+        await UI.ViewManager.ViewManager.instance().showView('timeline');
+        TimelinePanel.instance().loadFromCpuProfile(data.cpuProfile, title);
+      }
+    });
+    ProfileFinishedRevealer.#consoleProfilePromiseChain = taskPromise.catch(() => {});
+    return await taskPromise;
   }
 }
 

package/front_end/panels/timeline/timelineHistoryManager.css

@@ -54,6 +54,10 @@
 
 .text-details .name {
   font: var(--sys-typescale-body4-medium);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  max-width: 240px;
 }
 
 .text-details .metadata {

package/front_end/third_party/chromium/README.chromium

@@ -1,7 +1,7 @@
 Name: Dependencies sourced from the upstream `chromium` repository
 URL: Internal
 Version: N/A
-Revision: c15d009df51d794d8a37df41cdc89d4056e7e0cd
+Revision: b7fe14017379ddffae396d944fb8b59a5896c261
 Update Mechanism: Manual (https://crbug.com/428069060)
 License: BSD-3-Clause
 License File: LICENSE

package/front_end/third_party/puppeteer/README.chromium

@@ -1,10 +1,10 @@
 Name: Puppeteer Core
 Short Name: Puppeteer Core
 URL: https://github.com/puppeteer/puppeteer/tree/main/packages/puppeteer-core
-Version: 25.3.0
+Version: 25.4.0
 License: Apache-2.0
 License File: LICENSE
-Revision: 58d9b023ed74c3a1f14ec5fd9315872602270c72
+Revision: f5b96c54c01d4bcbeaa3c603ec5adf6782363b29
 Security Critical: no
 Shipped: yes
 Update Mechanism: Autoroll

package/front_end/third_party/puppeteer/package/lib/es5-iife/puppeteer-core-browser.d.ts

@@ -123,6 +123,11 @@ export declare interface AddScreenParams {
   isInternal?: boolean;
 }
 
+/**
+ * @public
+ */
+export declare const asyncDisposeSymbol: typeof Symbol.asyncDispose;
+
 /**
  * Supported autofill address field names.
  *
@@ -567,6 +572,55 @@ export declare abstract class Browser extends EventEmitter<BrowserEvents> {
    * Uninstalls an extension.
    */
   abstract uninstallExtension(id: string): Promise<void>;
+  /**
+   * Installs a Progressive Web App (PWA) and returns its manifest id.
+   *
+   * @remarks
+   *
+   * Only available when connected to the browser over a pipe connection. Set
+   * `pipe: true` in {@link PuppeteerNode.launch | puppeteer.launch}; the launch
+   * option defaults to `false`. The underlying `PWA` CDP domain is not exposed
+   * over a WebSocket connection.
+   *
+   * The returned manifest id echoes {@link InstallPWAOptions.manifestId}, so it
+   * can be passed directly to {@link Browser.launchPWA},
+   * {@link Browser.getPWAState}, or {@link Browser.uninstallPWA}.
+   */
+  abstract installPWA(options: InstallPWAOptions): Promise<string>;
+  /**
+   * Uninstalls a previously installed Progressive Web App (PWA).
+   *
+   * @remarks
+   *
+   * Only available over a pipe connection. See {@link Browser.installPWA}.
+   */
+  abstract uninstallPWA(options: UninstallPWAOptions): Promise<void>;
+  /**
+   * Launches an installed Progressive Web App (PWA) and resolves with the
+   * {@link Page | page} backing the app window.
+   *
+   * @remarks
+   *
+   * Only available over a pipe connection. See {@link Browser.installPWA}.
+   *
+   * `PWA.launch` resolves with the id of the launched _tab_ target. Puppeteer
+   * does not expose tab targets through {@link Browser.targets}; this method
+   * instead resolves with the tab's child page target (the app's web contents).
+   * If Chromium focuses an existing app window, this returns that window's
+   * existing page.
+   */
+  abstract launchPWA(options: LaunchPWAOptions): Promise<Page>;
+  /**
+   * Returns the OS-integration state of an installed Progressive Web App (PWA),
+   * such as its badge count and registered file handlers.
+   *
+   * @remarks
+   *
+   * Only available over a pipe connection. See {@link Browser.installPWA}.
+   * Meaningful only for an app that is currently installed; querying an
+   * unknown manifest id rejects.
+   */
+  abstract getPWAState(options: GetPWAStateOptions): Promise<PWAState>;
   /**
    * Gets a list of {@link ScreenInfo | screen information objects}.
    */
@@ -591,6 +645,8 @@ export declare abstract class Browser extends EventEmitter<BrowserEvents> {
    * Whether Puppeteer is connected to this {@link Browser | browser}.
    */
   abstract get connected(): boolean;
+  [disposeSymbol](): void;
+  [asyncDisposeSymbol](): Promise<void>;
   /**
    * Get debug information from Puppeteer.
    *
@@ -788,6 +844,8 @@ export declare abstract class BrowserContext extends EventEmitter<BrowserContext
    * Identifier for this {@link BrowserContext | browser context}.
    */
   get id(): string | undefined;
+  [disposeSymbol](): void;
+  [asyncDisposeSymbol](): Promise<void>;
 }
 
 /**
@@ -2067,6 +2125,11 @@ export declare interface DeviceRequestPromptDevice {
  */
 export declare abstract class Dialog {
   
+  /**
+   * A boolean value indicating whether the dialog has been handled.
+   */
+  get handled(): boolean;
+  protected set handled(handled: boolean);
   /**
    * The type of the dialog.
    */
@@ -2094,6 +2157,11 @@ export declare abstract class Dialog {
   dismiss(): Promise<void>;
 }
 
+/**
+ * @public
+ */
+export declare const disposeSymbol: typeof Symbol.dispose;
+
 /**
  * @public
  */
@@ -2794,6 +2862,8 @@ export declare class EventEmitter<
    * @returns `this` to enable you to chain method calls.
    */
   removeAllListeners(type?: keyof EventsWithWildcard<Events>): this;
+  [disposeSymbol](): void;
+  [asyncDisposeSymbol](): Promise<void>;
 }
 
 /**
@@ -3731,6 +3801,18 @@ export declare interface GeolocationOptions {
   accuracy?: number;
 }
 
+/**
+ * Options for {@link Browser.getPWAState}.
+ *
+ * @public
+ */
+export declare interface GetPWAStateOptions {
+  /**
+   * The id from the web app's manifest file.
+   */
+  manifestId: string;
+}
+
 /**
  * @public
  */
@@ -4157,6 +4239,37 @@ export declare type InnerParams<T extends unknown[]> = {
   [K in keyof T]: FlattenHandle<T[K]>;
 };
 
+/**
+ * Options for {@link Browser.installPWA}.
+ *
+ * @public
+ */
+export declare interface InstallPWAOptions {
+  /**
+   * The id from the web app's manifest file, commonly the URL of the site
+   * installing the web app. See
+   * {@link https://web.dev/learn/pwa/web-app-manifest | Web app manifest}.
+   */
+  manifestId: string;
+  /**
+   * The URL used to install the app, or the URL of its signed web bundle.
+   *
+   * This is required because the browser-scoped CDP session has no associated
+   * page from which Chromium could derive an install URL.
+   */
+  installUrlOrBundleUrl: string;
+  /**
+   * Whether the app should open in a standalone window or a browser tab.
+   *
+   * @remarks
+   *
+   * `PWA.install` alone leaves the app at Chromium's default display mode
+   * (`browser`); setting this chains a `PWA.changeAppUserSettings` call to apply
+   * the preference.
+   */
+  displayMode?: PWADisplayMode;
+}
+
 /**
  * @public
  */
@@ -4355,6 +4468,8 @@ export declare abstract class JSHandle<T = unknown> {
    * backing this handle.
    */
   abstract remoteObject(): Protocol.Runtime.RemoteObject;
+  [disposeSymbol](): void;
+  [asyncDisposeSymbol](): Promise<void>;
 }
 
 /**
@@ -5100,6 +5215,28 @@ export declare interface LaunchOptions extends ConnectOptions {
   signal?: AbortSignal;
 }
 
+/**
+ * Options for {@link Browser.launchPWA}.
+ *
+ * @public
+ */
+export declare interface LaunchPWAOptions {
+  /**
+   * The id from the web app's manifest file.
+   */
+  manifestId: string;
+  /**
+   * An optional URL within the app's scope to launch. Defaults to the app's
+   * start URL.
+   */
+  url?: string;
+  /**
+   * Maximum time in milliseconds to wait for the app's page target to appear.
+   * Defaults to 30 seconds. Pass `0` to disable the timeout.
+   */
+  timeout?: number;
+}
+
 /**
  * Locators describe a strategy of locating objects and performing an action on
  * them. If the action fails because the object is not ready for the action, the
@@ -5817,7 +5954,7 @@ export declare abstract class Page extends EventEmitter<PageEvents> {
   abstract get tracing(): Tracing;
   /**
    * Experimental API for {@link https://github.com/webmachinelearning/webmcp| WebMCP}.
-   * Requires Chrome 150+ with the `--enable-features=WebMCP` flag enabled.
+   * Requires Chrome 151+ with the `--enable-features=WebMCP` flag enabled.
    *
    * @experimental
    */
@@ -7560,6 +7697,8 @@ export declare abstract class Page extends EventEmitter<PageEvents> {
    * @experimental
    */
   abstract windowId(): Promise<WindowId>;
+  [disposeSymbol](): void;
+  [asyncDisposeSymbol](): Promise<void>;
   /**
    * Opens DevTools for the this page if not already open and returns the DevTools page.
    * This method is only available in Chrome.
@@ -8188,6 +8327,12 @@ declare namespace Puppeteer_2 {
     WorkAreaInsets,
     AddScreenParams,
     ExtensionInstallOptions,
+    PWADisplayMode,
+    InstallPWAOptions,
+    UninstallPWAOptions,
+    LaunchPWAOptions,
+    GetPWAStateOptions,
+    PWAState,
     BrowserContextEvents,
     CDPEvents,
     CDPSessionEvents,
@@ -8371,6 +8516,8 @@ declare namespace Puppeteer_2 {
     FileChooser,
     Puppeteer,
     SecurityDetails,
+    disposeSymbol,
+    asyncDisposeSymbol,
     BrowserLauncher,
     PuppeteerNode,
     ScreenRecorder,
@@ -8537,6 +8684,31 @@ export declare class PuppeteerNode extends Puppeteer {
   trimCache(): Promise<void>;
 }
 
+/**
+ * If the user prefers opening an installed web app in a standalone window or in
+ * a browser tab.
+ *
+ * @public
+ */
+export declare type PWADisplayMode = 'standalone' | 'browser';
+
+/**
+ * The OS-integration state of an installed web app, returned by
+ * {@link Browser.getPWAState}.
+ *
+ * @public
+ */
+export declare interface PWAState {
+  /**
+   * The current badge count shown on the app icon.
+   */
+  badgeCount: number;
+  /**
+   * The file handlers registered by the app with the OS.
+   */
+  fileHandlers: Protocol.PWA.FileHandler[];
+}
+
 /**
  * @public
  */
@@ -8682,6 +8854,7 @@ export declare abstract class Realm {
     },
     ...args: Params
   ): Promise<HandleFor<Awaited<ReturnType<Func>>>>;
+  [disposeSymbol](): void;
 }
 
 /**
@@ -8865,6 +9038,7 @@ export declare class ScreenRecorder extends PassThrough {
    * @public
    */
   stop(): Promise<void>;
+  [asyncDisposeSymbol](): Promise<void>;
 }
 
 /**
@@ -9338,6 +9512,18 @@ export declare interface TracingOptions {
   categories?: string[];
 }
 
+/**
+ * Options for {@link Browser.uninstallPWA}.
+ *
+ * @public
+ */
+export declare interface UninstallPWAOptions {
+  /**
+   * The id from the web app's manifest file.
+   */
+  manifestId: string;
+}
+
 /**
  * Puppeteer will throw this error if a method is not
  * supported by the currently used protocol