lighthouse 12.0.0-dev.20240610 → 12.0.0-dev.20240612

package/core/lib/lantern/{page-dependency-graph.d.ts → PageDependencyGraph.d.ts}

@@ -1,5 +1,4 @@
-export type Node = import('./base-node.js').Node;
-export type URLArtifact = Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>;
+export type Node = import('./BaseNode.js').Node;
 export type NetworkNodeOutput = {
     nodes: Array<NetworkNode>;
     idToNodeMap: Map<string, NetworkNode>;
@@ -18,10 +17,22 @@ export class PageDependencyGraph {
      */
     static getNetworkNodeOutput(networkRequests: Array<Lantern.NetworkRequest>): NetworkNodeOutput;
     /**
-     * @param {LH.TraceEvent[]} mainThreadEvents
+     * @param {Lantern.TraceEvent} evt
+     * @return {boolean}
+     */
+    static isScheduleableTask(evt: Lantern.TraceEvent): boolean;
+    /**
+     * There should *always* be at least one top level event, having 0 typically means something is
+     * drastically wrong with the trace and we should just give up early and loudly.
+     *
+     * @param {Lantern.TraceEvent[]} events
+     */
+    static assertHasToplevelEvents(events: Lantern.TraceEvent[]): void;
+    /**
+     * @param {Lantern.TraceEvent[]} mainThreadEvents
      * @return {Array<CPUNode>}
      */
-    static getCPUNodes(mainThreadEvents: LH.TraceEvent[]): Array<CPUNode>;
+    static getCPUNodes(mainThreadEvents: Lantern.TraceEvent[]): Array<CPUNode>;
     /**
      * @param {NetworkNode} rootNode
      * @param {NetworkNodeOutput} networkNodeOutput
@@ -54,18 +65,18 @@ export class PageDependencyGraph {
      */
     static _debugNormalizeRequests(lanternRequests: Lantern.NetworkRequest[]): never;
     /**
-     * @param {LH.TraceEvent[]} mainThreadEvents
+     * @param {Lantern.TraceEvent[]} mainThreadEvents
      * @param {Lantern.NetworkRequest[]} networkRequests
-     * @param {URLArtifact} URL
+     * @param {Lantern.Simulation.URL} URL
      * @return {Node}
      */
-    static createGraph(mainThreadEvents: LH.TraceEvent[], networkRequests: Lantern.NetworkRequest[], URL: URLArtifact): Node;
+    static createGraph(mainThreadEvents: Lantern.TraceEvent[], networkRequests: Lantern.NetworkRequest[], URL: Lantern.Simulation.URL): Node;
     /**
      * @param {Node} rootNode
      */
     static printGraph(rootNode: Node, widthInCharacters?: number): void;
 }
-import { NetworkNode } from './network-node.js';
-import * as Lantern from './types/lantern.js';
-import { CPUNode } from './cpu-node.js';
-//# sourceMappingURL=page-dependency-graph.d.ts.map
+import { NetworkNode } from './NetworkNode.js';
+import * as Lantern from './lantern.js';
+import { CPUNode } from './CpuNode.js';
+//# sourceMappingURL=PageDependencyGraph.d.ts.map

package/core/lib/lantern/{page-dependency-graph.js → PageDependencyGraph.js}

@@ -4,15 +4,20 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from './types/lantern.js';
-import {NetworkRequestTypes} from './lantern.js';
-import {NetworkNode} from './network-node.js';
-import {CPUNode} from './cpu-node.js';
-import {TraceProcessor} from '../tracehouse/trace-processor.js';
-import {NetworkAnalyzer} from './simulator/network-analyzer.js';
+import * as Lantern from './lantern.js';
+import {NetworkNode} from './NetworkNode.js';
+import {CPUNode} from './CpuNode.js';
 
-/** @typedef {import('./base-node.js').Node} Node */
-/** @typedef {Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>} URLArtifact */
+// COMPAT: m71+ We added RunTask to `disabled-by-default-lighthouse`
+const SCHEDULABLE_TASK_TITLE_LH = 'RunTask';
+// m69-70 DoWork is different and we now need RunTask, see https://bugs.chromium.org/p/chromium/issues/detail?id=871204#c11
+const SCHEDULABLE_TASK_TITLE_ALT1 = 'ThreadControllerImpl::RunTask';
+// In m66-68 refactored to this task title, https://crrev.com/c/883346
+const SCHEDULABLE_TASK_TITLE_ALT2 = 'ThreadControllerImpl::DoWork';
+// m65 and earlier
+const SCHEDULABLE_TASK_TITLE_ALT3 = 'TaskQueueManager::ProcessTaskFromWorkQueue';
+
+/** @typedef {import('./BaseNode.js').Node} Node */
 
 /**
  * @typedef {Object} NetworkNodeOutput
@@ -97,7 +102,7 @@ class PageDependencyGraph {
       // If the request was for the root document of an iframe, save an entry in our
       // map so we can link up the task `args.data.frame` dependencies later in graph creation.
       if (request.frameId &&
-          request.resourceType === NetworkRequestTypes.Document &&
+          request.resourceType === Lantern.NetworkRequestTypes.Document &&
           request.documentURL === request.url) {
         // If there's ever any ambiguity, permanently set the value to `false` to avoid loops in the graph.
         const value = frameIdToNodeMap.has(request.frameId) ? null : node;
@@ -109,7 +114,31 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {LH.TraceEvent[]} mainThreadEvents
+   * @param {Lantern.TraceEvent} evt
+   * @return {boolean}
+   */
+  static isScheduleableTask(evt) {
+    return evt.name === SCHEDULABLE_TASK_TITLE_LH ||
+      evt.name === SCHEDULABLE_TASK_TITLE_ALT1 ||
+      evt.name === SCHEDULABLE_TASK_TITLE_ALT2 ||
+      evt.name === SCHEDULABLE_TASK_TITLE_ALT3;
+  }
+
+  /**
+   * There should *always* be at least one top level event, having 0 typically means something is
+   * drastically wrong with the trace and we should just give up early and loudly.
+   *
+   * @param {Lantern.TraceEvent[]} events
+   */
+  static assertHasToplevelEvents(events) {
+    const hasToplevelTask = events.some(this.isScheduleableTask);
+    if (!hasToplevelTask) {
+      throw new Error('Could not find any top level events');
+    }
+  }
+
+  /**
+   * @param {Lantern.TraceEvent[]} mainThreadEvents
    * @return {Array<CPUNode>}
    */
   static getCPUNodes(mainThreadEvents) {
@@ -117,14 +146,14 @@ class PageDependencyGraph {
     const nodes = [];
     let i = 0;
 
-    TraceProcessor.assertHasToplevelEvents(mainThreadEvents);
+    PageDependencyGraph.assertHasToplevelEvents(mainThreadEvents);
 
     while (i < mainThreadEvents.length) {
       const evt = mainThreadEvents[i];
       i++;
 
       // Skip all trace events that aren't schedulable tasks with sizable duration
-      if (!TraceProcessor.isScheduleableTask(evt) || !evt.dur) {
+      if (!PageDependencyGraph.isScheduleableTask(evt) || !evt.dur) {
         continue;
       }
 
@@ -132,23 +161,25 @@ class PageDependencyGraph {
       let correctedEndTs = undefined;
 
       // Capture all events that occurred within the task
-      /** @type {Array<LH.TraceEvent>} */
+      /** @type {Array<Lantern.TraceEvent>} */
       const children = [];
       for (
         const endTime = evt.ts + evt.dur;
         i < mainThreadEvents.length && mainThreadEvents[i].ts < endTime;
         i++
       ) {
+        const event = mainThreadEvents[i];
+
         // Temporary fix for a Chrome bug where some RunTask events can be overlapping.
         // We correct that here be ensuring each RunTask ends at least 1 microsecond before the next
         // https://github.com/GoogleChrome/lighthouse/issues/15896
         // https://issues.chromium.org/issues/329678173
-        if (TraceProcessor.isScheduleableTask(mainThreadEvents[i]) && mainThreadEvents[i].dur) {
-          correctedEndTs = mainThreadEvents[i].ts - 1;
+        if (PageDependencyGraph.isScheduleableTask(event) && event.dur) {
+          correctedEndTs = event.ts - 1;
           break;
         }
 
-        children.push(mainThreadEvents[i]);
+        children.push(event);
       }
 
       nodes.push(new CPUNode(evt, children, correctedEndTs));
@@ -210,9 +241,11 @@ class PageDependencyGraph {
    * @param {Array<CPUNode>} cpuNodes
    */
   static linkCPUNodes(rootNode, networkNodeOutput, cpuNodes) {
-    /** @type {Set<LH.Crdp.Network.ResourceType|undefined>} */
+    /** @type {Set<Lantern.ResourceType|undefined>} */
     const linkableResourceTypes = new Set([
-      NetworkRequestTypes.XHR, NetworkRequestTypes.Fetch, NetworkRequestTypes.Script,
+      Lantern.NetworkRequestTypes.XHR,
+      Lantern.NetworkRequestTypes.Fetch,
+      Lantern.NetworkRequestTypes.Script,
     ]);
 
     /** @param {CPUNode} cpuNode @param {string} reqId */
@@ -506,9 +539,9 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {LH.TraceEvent[]} mainThreadEvents
+   * @param {Lantern.TraceEvent[]} mainThreadEvents
    * @param {Lantern.NetworkRequest[]} networkRequests
-   * @param {URLArtifact} URL
+   * @param {Lantern.Simulation.URL} URL
    * @return {Node}
    */
   static createGraph(mainThreadEvents, networkRequests, URL) {
@@ -520,12 +553,13 @@ class PageDependencyGraph {
     if (!requestedUrl) throw new Error('requestedUrl is required to get the root request');
     if (!mainDocumentUrl) throw new Error('mainDocumentUrl is required to get the main resource');
 
-    const rootRequest = NetworkAnalyzer.findResourceForUrl(networkRequests, requestedUrl);
+    const rootRequest =
+      Lantern.Simulation.NetworkAnalyzer.findResourceForUrl(networkRequests, requestedUrl);
     if (!rootRequest) throw new Error('rootRequest not found');
     const rootNode = networkNodeOutput.idToNodeMap.get(rootRequest.requestId);
     if (!rootNode) throw new Error('rootNode not found');
     const mainDocumentRequest =
-      NetworkAnalyzer.findLastDocumentForUrl(networkRequests, mainDocumentUrl);
+      Lantern.Simulation.NetworkAnalyzer.findLastDocumentForUrl(networkRequests, mainDocumentUrl);
     if (!mainDocumentRequest) throw new Error('mainDocumentRequest not found');
     const mainDocumentNode = networkNodeOutput.idToNodeMap.get(mainDocumentRequest.requestId);
     if (!mainDocumentNode) throw new Error('mainDocumentNode not found');