devtools-tracing 1.1.1 → 1.2.1

package/lib/front_end/models/trace/lantern/graph/BaseNode.ts

@@ -1,345 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Core from '../core/core.js';
-import type * as Lantern from '../types/types.js';
-
-import type {CPUNode} from './CPUNode.js';
-import type {NetworkNode} from './NetworkNode.js';
-
-/**
- * A union of all types derived from BaseNode, allowing type check discrimination
- * based on `node.type`. If a new node type is created, it should be added here.
- */
-export type Node<T = Lantern.AnyNetworkObject> = CPUNode<T>|NetworkNode<T>;
-
-/**
- * @file This class encapsulates logic for handling resources and tasks used to model the
- * execution dependency graph of the page. A node has a unique identifier and can depend on other
- * nodes/be depended on. The construction of the graph maintains some important invariants that are
- * inherent to the model:
- *
- *    1. The graph is a DAG, there are no cycles.
- *    2. There is always a root node upon which all other nodes eventually depend.
- *
- * This allows particular optimizations in this class so that we do no need to check for cycles as
- * these methods are called and we can always start traversal at the root node.
- */
-
-class BaseNode<T = Lantern.AnyNetworkObject> {
-  static types = {
-    NETWORK: 'network',
-    CPU: 'cpu',
-  } as const;
-
-  _id: string;
-  _isMainDocument: boolean;
-  dependents: Node[];
-  dependencies: Node[];
-
-  constructor(id: string) {
-    this._id = id;
-    this._isMainDocument = false;
-    this.dependents = [];
-    this.dependencies = [];
-  }
-
-  get id(): string {
-    return this._id;
-  }
-
-  get type(): 'network'|'cpu' {
-    throw new Core.LanternError('Unimplemented');
-  }
-
-  /**
-   * In microseconds
-   */
-  get startTime(): number {
-    throw new Core.LanternError('Unimplemented');
-  }
-
-  /**
-   * In microseconds
-   */
-  get endTime(): number {
-    throw new Core.LanternError('Unimplemented');
-  }
-
-  setIsMainDocument(value: boolean): void {
-    this._isMainDocument = value;
-  }
-
-  isMainDocument(): boolean {
-    return this._isMainDocument;
-  }
-
-  getDependents(): Node[] {
-    return this.dependents.slice();
-  }
-
-  getNumberOfDependents(): number {
-    return this.dependents.length;
-  }
-
-  getDependencies(): Node[] {
-    return this.dependencies.slice();
-  }
-
-  getNumberOfDependencies(): number {
-    return this.dependencies.length;
-  }
-
-  getRootNode(): Node<T> {
-    let rootNode = this as BaseNode as Node;
-    while (rootNode.dependencies.length) {
-      rootNode = rootNode.dependencies[0];
-    }
-
-    return rootNode;
-  }
-
-  addDependent(node: Node): void {
-    node.addDependency(this as BaseNode as Node);
-  }
-
-  addDependency(node: Node): void {
-    // @ts-expect-error - in checkJs, ts doesn't know that CPUNode and NetworkNode *are* BaseNodes.
-    if (node === this) {
-      throw new Core.LanternError('Cannot add dependency on itself');
-    }
-
-    if (this.dependencies.includes(node)) {
-      return;
-    }
-
-    node.dependents.push(this as BaseNode as Node);
-    this.dependencies.push(node);
-  }
-
-  removeDependent(node: Node): void {
-    node.removeDependency(this as BaseNode as Node);
-  }
-
-  removeDependency(node: Node): void {
-    if (!this.dependencies.includes(node)) {
-      return;
-    }
-
-    const thisIndex = node.dependents.indexOf(this as BaseNode as Node);
-    node.dependents.splice(thisIndex, 1);
-    this.dependencies.splice(this.dependencies.indexOf(node), 1);
-  }
-
-  // Unused in devtools, but used in LH.
-  removeAllDependencies(): void {
-    for (const node of this.dependencies.slice()) {
-      this.removeDependency(node);
-    }
-  }
-
-  /**
-   * Computes whether the given node is anywhere in the dependency graph of this node.
-   * While this method can prevent cycles, it walks the graph and should be used sparingly.
-   * Nodes are always considered dependent on themselves for the purposes of cycle detection.
-   */
-  isDependentOn(node: BaseNode<T>): boolean {
-    let isDependentOnNode = false;
-    this.traverse(
-        currentNode => {
-          if (isDependentOnNode) {
-            return;
-          }
-          isDependentOnNode = currentNode === node;
-        },
-        currentNode => {
-          // If we've already found the dependency, don't traverse further.
-          if (isDependentOnNode) {
-            return [];
-          }
-          // Otherwise, traverse the dependencies.
-          return currentNode.getDependencies();
-        });
-
-    return isDependentOnNode;
-  }
-
-  /**
-   * Clones the node's information without adding any dependencies/dependents.
-   */
-  cloneWithoutRelationships(): Node<T> {
-    const node = new BaseNode(this.id) as Node<T>;
-    node.setIsMainDocument(this._isMainDocument);
-    return node;
-  }
-
-  /**
-   * Clones the entire graph connected to this node filtered by the optional predicate. If a node is
-   * included by the predicate, all nodes along the paths between the node and the root will be included. If the
-   * node this was called on is not included in the resulting filtered graph, the method will throw.
-   *
-   * This does not clone NetworkNode's `record` or `rawRecord` fields. It may be reasonable to clone the former,
-   * to assist in graph construction, but the latter should never be cloned as one constraint of Lantern is that
-   * the underlying data records are accessible for plain object reference equality checks.
-   */
-  cloneWithRelationships(predicate?: (arg0: Node) => boolean): Node {
-    const rootNode = this.getRootNode();
-
-    const idsToIncludedClones = new Map<string, Node>();
-
-    // Walk down dependents.
-    rootNode.traverse(node => {
-      if (idsToIncludedClones.has(node.id)) {
-        return;
-      }
-
-      if (predicate === undefined) {
-        // No condition for entry, so clone every node.
-        idsToIncludedClones.set(node.id, node.cloneWithoutRelationships());
-        return;
-      }
-
-      if (predicate(node)) {
-        // Node included, so walk back up dependencies, cloning nodes from here back to the root.
-        node.traverse(
-            node => idsToIncludedClones.set(node.id, node.cloneWithoutRelationships()),
-            // Dependencies already cloned have already cloned ancestors, so no need to visit again.
-            node => node.dependencies.filter(parent => !idsToIncludedClones.has(parent.id)),
-        );
-      }
-    });
-
-    // Copy dependencies between nodes.
-    rootNode.traverse(originalNode => {
-      const clonedNode = idsToIncludedClones.get(originalNode.id);
-      if (!clonedNode) {
-        return;
-      }
-
-      for (const dependency of originalNode.dependencies) {
-        const clonedDependency = idsToIncludedClones.get(dependency.id);
-        if (!clonedDependency) {
-          throw new Core.LanternError('Dependency somehow not cloned');
-        }
-        clonedNode.addDependency(clonedDependency);
-      }
-    });
-
-    const clonedThisNode = idsToIncludedClones.get(this.id);
-    if (!clonedThisNode) {
-      throw new Core.LanternError('Cloned graph missing node');
-    }
-    return clonedThisNode;
-  }
-
-  /**
-   * Traverses all connected nodes in BFS order, calling `callback` exactly once
-   * on each. `traversalPath` is the shortest (though not necessarily unique)
-   * path from `node` to the root of the iteration.
-   *
-   * The `getNextNodes` function takes a visited node and returns which nodes to
-   * visit next. It defaults to returning the node's dependents.
-   */
-  traverse(
-      callback: (node: Node<T>, traversalPath: Array<Node<T>>) => void,
-      getNextNodes?: (arg0: Node<T>) => Array<Node<T>>): void {
-    for (const {node, traversalPath} of this.traverseGenerator(getNextNodes)) {
-      callback(node, traversalPath);
-    }
-  }
-
-  /**
-   * @see BaseNode.traverse
-   */
-  // clang-format off
-  *traverseGenerator(getNextNodes?: (arg0: Node) => Node[]):
-      Generator<{node: Node, traversalPath: Node[]}, void, unknown> {
-    // clang-format on
-    if (!getNextNodes) {
-      getNextNodes = node => node.getDependents();
-    }
-
-    // @ts-expect-error - only traverses graphs of Node, so force tsc to treat `this` as one
-    const queue: Node[][] = [[this]];
-    const visited = new Set([this.id]);
-
-    while (queue.length) {
-      // @ts-expect-error - queue has length so it's guaranteed to have an item
-      const traversalPath: Node[] = queue.shift();
-      const node = traversalPath[0];
-      yield {node, traversalPath};
-
-      for (const nextNode of getNextNodes(node)) {
-        if (visited.has(nextNode.id)) {
-          continue;
-        }
-        visited.add(nextNode.id);
-
-        queue.push([nextNode, ...traversalPath]);
-      }
-    }
-  }
-
-  /**
-   * If the given node has a cycle, returns a path representing that cycle.
-   * Else returns null.
-   *
-   * Does a DFS on in its dependent graph.
-   */
-  static findCycle(node: Node, direction: 'dependents'|'dependencies'|'both' = 'both'): BaseNode[]|null {
-    // Checking 'both' is the default entrypoint to recursively check both directions
-    if (direction === 'both') {
-      return BaseNode.findCycle(node, 'dependents') || BaseNode.findCycle(node, 'dependencies');
-    }
-
-    const visited = new Set();
-    const currentPath: BaseNode[] = [];
-    const toVisit = [node];
-    const depthAdded = new Map([[node, 0]]);
-
-    // Keep going while we have nodes to visit in the stack
-    while (toVisit.length) {
-      // Get the last node in the stack (DFS uses stack, not queue)
-      // @ts-expect-error - toVisit has length so it's guaranteed to have an item
-      const currentNode: BaseNode = toVisit.pop();
-
-      // We've hit a cycle if the node we're visiting is in our current dependency path
-      if (currentPath.includes(currentNode)) {
-        return currentPath;
-      }
-      // If we've already visited the node, no need to revisit it
-      if (visited.has(currentNode)) {
-        continue;
-      }
-
-      // Since we're visiting this node, clear out any nodes in our path that we had to backtrack
-      // @ts-expect-error
-      while (currentPath.length > depthAdded.get(currentNode)) {
-        currentPath.pop();
-      }
-
-      // Update our data structures to reflect that we're adding this node to our path
-      visited.add(currentNode);
-      currentPath.push(currentNode);
-
-      // Add all of its dependents to our toVisit stack
-      const nodesToExplore = direction === 'dependents' ? currentNode.dependents : currentNode.dependencies;
-      for (const nextNode of nodesToExplore) {
-        if (toVisit.includes(nextNode)) {
-          continue;
-        }
-        toVisit.push(nextNode);
-        depthAdded.set(nextNode, currentPath.length);
-      }
-    }
-
-    return null;
-  }
-
-  canDependOn(node: Node): boolean {
-    return node.startTime <= this.startTime;
-  }
-}
-
-export {BaseNode};

package/lib/front_end/models/trace/lantern/graph/CPUNode.ts

@@ -1,80 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import type * as Lantern from '../types/types.js';
-
-import {BaseNode} from './BaseNode.js';
-
-class CPUNode<T = Lantern.AnyNetworkObject> extends BaseNode<T> {
-  _event: Lantern.TraceEvent;
-  _childEvents: Lantern.TraceEvent[];
-  correctedEndTs: number|undefined;
-
-  constructor(parentEvent: Lantern.TraceEvent, childEvents: Lantern.TraceEvent[] = [], correctedEndTs?: number) {
-    const nodeId = `${parentEvent.tid}.${parentEvent.ts}`;
-    super(nodeId);
-
-    this._event = parentEvent;
-    this._childEvents = childEvents;
-    this.correctedEndTs = correctedEndTs;
-  }
-
-  override get type(): 'cpu' {
-    return BaseNode.types.CPU;
-  }
-
-  override get startTime(): number {
-    return this._event.ts;
-  }
-
-  override get endTime(): number {
-    if (this.correctedEndTs) {
-      return this.correctedEndTs;
-    }
-    return this._event.ts + this._event.dur;
-  }
-
-  get duration(): number {
-    return this.endTime - this.startTime;
-  }
-
-  get event(): Lantern.TraceEvent {
-    return this._event;
-  }
-
-  get childEvents(): Lantern.TraceEvent[] {
-    return this._childEvents;
-  }
-
-  /**
-   * Returns true if this node contains a Layout task.
-   */
-  didPerformLayout(): boolean {
-    return this._childEvents.some(evt => evt.name === 'Layout');
-  }
-
-  /**
-   * Returns the script URLs that had their EvaluateScript events occur in this task.
-   */
-  getEvaluateScriptURLs(): Set<string> {
-    const urls = new Set<string>();
-    for (const event of this._childEvents) {
-      if (event.name !== 'EvaluateScript') {
-        continue;
-      }
-      if (!event.args.data?.url) {
-        continue;
-      }
-      urls.add(event.args.data.url);
-    }
-
-    return urls;
-  }
-
-  override cloneWithoutRelationships(): CPUNode {
-    return new CPUNode(this._event, this._childEvents, this.correctedEndTs);
-  }
-}
-
-export {CPUNode};

package/lib/front_end/models/trace/lantern/graph/NetworkNode.ts

@@ -1,101 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import type * as Lantern from '../types/types.js';
-
-import {BaseNode} from './BaseNode.js';
-
-const NON_NETWORK_SCHEMES = [
-  'blob',        // @see https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
-  'data',        // @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
-  'intent',      // @see https://developer.chrome.com/docs/multidevice/android/intents/
-  'file',        // @see https://en.wikipedia.org/wiki/File_URI_scheme
-  'filesystem',  // @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystem
-  'chrome-extension',
-];
-
-/**
- * Note: the `protocol` field from CDP can be 'h2', 'http', (not 'https'!) or it'll be url's scheme.
- *   https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/protocol/network_handler.cc;l=598-611;drc=56d4a9a9deb30be73adcee8737c73bcb2a5ab64f
- * However, a `new URL(href).protocol` has a colon suffix.
- *   https://url.spec.whatwg.org/#dom-url-protocol
- * A URL's `scheme` is specced as the `protocol` sans-colon, but isn't exposed on a URL object.
- * This method can take all 3 of these string types as a parameter.
- *
- * @param protocol Either a networkRequest's `protocol` per CDP or a `new URL(href).protocol`
- */
-function isNonNetworkProtocol(protocol: string): boolean {
-  // Strip off any colon
-  const urlScheme = protocol.includes(':') ? protocol.slice(0, protocol.indexOf(':')) : protocol;
-  return NON_NETWORK_SCHEMES.includes(urlScheme);
-}
-
-class NetworkNode<T = Lantern.AnyNetworkObject> extends BaseNode<T> {
-  _request: Lantern.NetworkRequest<T>;
-
-  constructor(networkRequest: Lantern.NetworkRequest<T>) {
-    super(networkRequest.requestId);
-    this._request = networkRequest;
-  }
-
-  override get type(): 'network' {
-    return BaseNode.types.NETWORK;
-  }
-
-  override get startTime(): number {
-    return this._request.rendererStartTime * 1000;
-  }
-
-  override get endTime(): number {
-    return this._request.networkEndTime * 1000;
-  }
-
-  get rawRequest(): Readonly<T> {
-    return this._request.rawRequest as Required<T>;
-  }
-
-  get request(): Lantern.NetworkRequest<T> {
-    return this._request;
-  }
-
-  get initiatorType(): string {
-    return this._request.initiator.type;
-  }
-
-  get fromDiskCache(): boolean {
-    return Boolean(this._request.fromDiskCache);
-  }
-
-  get isNonNetworkProtocol(): boolean {
-    // The 'protocol' field in devtools a string more like a `scheme`
-    return isNonNetworkProtocol(this.request.protocol) ||
-        // But `protocol` can fail to be populated if the request fails, so fallback to scheme.
-        isNonNetworkProtocol(this.request.parsedURL.scheme);
-  }
-
-  /**
-   * Returns whether this network request can be downloaded without a TCP connection.
-   * During simulation we treat data coming in over a network connection separately from on-device data.
-   */
-  get isConnectionless(): boolean {
-    return this.fromDiskCache || this.isNonNetworkProtocol;
-  }
-
-  hasRenderBlockingPriority(): boolean {
-    const priority = this._request.priority;
-    const isScript = this._request.resourceType === 'Script';
-    const isDocument = this._request.resourceType === 'Document';
-    const isBlockingScript = priority === 'High' && isScript;
-    const isBlockingHtmlImport = priority === 'High' && isDocument;
-    return priority === 'VeryHigh' || isBlockingScript || isBlockingHtmlImport;
-  }
-
-  override cloneWithoutRelationships(): NetworkNode<T> {
-    const node = new NetworkNode(this._request);
-    node.setIsMainDocument(this._isMainDocument);
-    return node;
-  }
-}
-
-export {NetworkNode};