devtools-tracing 1.1.0 → 1.2.0

package/lib/front_end/models/text_utils/WasmDisassembly.ts

@@ -1,87 +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 Platform from '../../core/platform/platform.js';
-
-import {ContentData} from './ContentData.js';
-import type {DeferredContent} from './ContentProvider.js';
-
-interface FunctionBodyOffset {
-  start: number;
-  end: number;
-}
-
-/**
- * Metadata to map between bytecode #offsets and line numbers in the
- * disassembly for WebAssembly modules.
- */
-export class WasmDisassembly extends ContentData {
-  readonly lines: string[];
-  readonly #offsets: number[];
-  #functionBodyOffsets: FunctionBodyOffset[];
-
-  // Wasm can be potentially very large, so we calculate `text' lazily.
-  #cachedText?: string;
-
-  constructor(lines: string[], offsets: number[], functionBodyOffsets: FunctionBodyOffset[]) {
-    super('', /* isBase64 */ false, 'text/x-wast', 'utf-8');
-    if (lines.length !== offsets.length) {
-      throw new Error('Lines and offsets don\'t match');
-    }
-    this.lines = lines;
-    this.#offsets = offsets;
-    this.#functionBodyOffsets = functionBodyOffsets;
-  }
-
-  override get text(): string {
-    if (typeof this.#cachedText === 'undefined') {
-      this.#cachedText = this.lines.join('\n');
-    }
-    return this.#cachedText;
-  }
-
-  override get isEmpty(): boolean {
-    // Don't trigger unnecessary concatenating. Only check whether we have no lines, or a single empty line.
-    return this.lines.length === 0 || (this.lines.length === 1 && this.lines[0].length === 0);
-  }
-
-  get lineNumbers(): number {
-    return this.#offsets.length;
-  }
-
-  bytecodeOffsetToLineNumber(bytecodeOffset: number): number {
-    return Platform.ArrayUtilities.upperBound(
-               this.#offsets, bytecodeOffset, Platform.ArrayUtilities.DEFAULT_COMPARATOR) -
-        1;
-  }
-
-  lineNumberToBytecodeOffset(lineNumber: number): number {
-    return this.#offsets[lineNumber];
-  }
-
-  /**
-   * returns an iterable enumerating all the non-breakable line numbers in the disassembly
-   */
-  * nonBreakableLineNumbers(): Iterable<number> {
-    let lineNumber = 0;
-    let functionIndex = 0;
-    while (lineNumber < this.lineNumbers) {
-      if (functionIndex < this.#functionBodyOffsets.length) {
-        const offset = this.lineNumberToBytecodeOffset(lineNumber);
-        if (offset >= this.#functionBodyOffsets[functionIndex].start) {
-          lineNumber = this.bytecodeOffsetToLineNumber(this.#functionBodyOffsets[functionIndex++].end) + 1;
-          continue;
-        }
-      }
-      yield lineNumber++;
-    }
-  }
-
-  /**
-   * @deprecated Used during migration from `DeferredContent` to `ContentData`.
-   */
-  override asDeferedContent(): DeferredContent {
-    return {content: '', isEncoded: false, wasmDisassemblyInfo: this};
-  }
-}

package/lib/front_end/models/text_utils/text_utils.ts

@@ -1,27 +0,0 @@
-// Copyright 2019 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 CodeMirrorUtils from './CodeMirrorUtils.js';
-import * as ContentData from './ContentData.js';
-import * as ContentProvider from './ContentProvider.js';
-import * as StaticContentProvider from './StaticContentProvider.js';
-import * as StreamingContentData from './StreamingContentData.js';
-import * as Text from './Text.js';
-import * as TextCursor from './TextCursor.js';
-import * as TextRange from './TextRange.js';
-import * as TextUtils from './TextUtils.js';
-import * as WasmDisassembly from './WasmDisassembly.js';
-
-export {
-  CodeMirrorUtils,
-  ContentData,
-  ContentProvider,
-  StaticContentProvider,
-  StreamingContentData,
-  Text,
-  TextCursor,
-  TextRange,
-  TextUtils,
-  WasmDisassembly,
-};

package/lib/front_end/models/trace/EntityMapper.ts

@@ -1,141 +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 Platform from '../../core/platform/platform.js';
-import type * as Protocol from '../../generated/protocol.js';
-
-import * as Handlers from './handlers/handlers.js';
-import * as Helpers from './helpers/helpers.js';
-import type {ParsedTrace} from './ModelImpl.js';
-import type * as Types from './types/types.js';
-
-export class EntityMapper {
-  #parsedTrace: ParsedTrace;
-  #entityMappings: Handlers.Helpers.EntityMappings;
-  #firstPartyEntity: Handlers.Helpers.Entity|null;
-  #thirdPartyEvents: Types.Events.Event[] = [];
-  /**
-   * When resolving urls and updating our entity mapping in the
-   * SourceMapsResolver, a single call frame can appear multiple times
-   * as different cpu profile nodes. To avoid duplicate work on the
-   * same CallFrame, we can keep track of them.
-   */
-  #resolvedCallFrames = new Set<Protocol.Runtime.CallFrame>();
-
-  constructor(parsedTrace: ParsedTrace) {
-    this.#parsedTrace = parsedTrace;
-    this.#entityMappings = this.#parsedTrace.data.Renderer.entityMappings;
-    this.#firstPartyEntity = this.#findFirstPartyEntity();
-    this.#thirdPartyEvents = this.#getThirdPartyEvents();
-  }
-
-  #findFirstPartyEntity(): Handlers.Helpers.Entity|null {
-    // As a starting point, we consider the first navigation as the 1P.
-    const nav =
-        Array.from(this.#parsedTrace.data.Meta.navigationsByNavigationId.values()).sort((a, b) => a.ts - b.ts)[0];
-    const firstPartyUrl = nav?.args.data?.documentLoaderURL ?? this.#parsedTrace.data.Meta.mainFrameURL;
-    if (!firstPartyUrl) {
-      return null;
-    }
-    return Handlers.Helpers.getEntityForUrl(firstPartyUrl, this.#entityMappings) ?? null;
-  }
-
-  #getThirdPartyEvents(): Types.Events.Event[] {
-    const entries = Array.from(this.#entityMappings.eventsByEntity.entries());
-    const thirdPartyEvents = entries.flatMap(([entity, events]) => {
-      return entity !== this.#firstPartyEntity ? events : [];
-    });
-    return thirdPartyEvents;
-  }
-
-  /**
-   * Returns an entity for a given event if any.
-   */
-  entityForEvent(event: Types.Events.Event): Handlers.Helpers.Entity|null {
-    return this.#entityMappings.entityByEvent.get(event) ?? null;
-  }
-
-  /**
-   * Returns trace events that correspond with a given entity if any.
-   */
-  eventsForEntity(entity: Handlers.Helpers.Entity): Types.Events.Event[] {
-    return this.#entityMappings.eventsByEntity.get(entity) ?? [];
-  }
-
-  firstPartyEntity(): Handlers.Helpers.Entity|null {
-    return this.#firstPartyEntity;
-  }
-
-  thirdPartyEvents(): Types.Events.Event[] {
-    return this.#thirdPartyEvents;
-  }
-
-  mappings(): Handlers.Helpers.EntityMappings {
-    return this.#entityMappings;
-  }
-
-  /**
-   * This updates entity mapping given a callFrame and sourceURL (newly resolved),
-   * updating both eventsByEntity and entityByEvent. The call frame provides us the
-   * URL and sourcemap source location that events map to. This describes the exact events we
-   * want to update. We then update the events with the new sourceURL.
-   *
-   * compiledURLs -> the actual file's url (e.g. my-big-bundle.min.js)
-   * sourceURLs -> the resolved urls (e.g. react.development.js, my-app.ts)
-   * @param callFrame
-   * @param sourceURL
-   */
-  updateSourceMapEntities(callFrame: Protocol.Runtime.CallFrame, sourceURL: string): void {
-    // Avoid the extra work, if we have already resolved this callFrame.
-    if (this.#resolvedCallFrames.has(callFrame)) {
-      return;
-    }
-
-    const compiledURL = callFrame.url;
-    const currentEntity = Handlers.Helpers.getEntityForUrl(compiledURL, this.#entityMappings);
-    const resolvedEntity = Handlers.Helpers.getEntityForUrl(sourceURL, this.#entityMappings);
-    // If the entity changed, then we should update our caches. If we don't have a currentEntity,
-    // we can't do much with that. Additionally without our current entity, we don't have a reference to the related
-    // events so there are no relationships to be made.
-    if ((resolvedEntity === currentEntity) || (!currentEntity || !resolvedEntity)) {
-      return;
-    }
-    const currentEntityEvents = (currentEntity && this.#entityMappings.eventsByEntity.get(currentEntity)) ?? [];
-    // The events of the entity that match said source location.
-    const sourceLocationEvents: Types.Events.Event[] = [];
-    // The events that don't match the source location, but that we should keep mapped to its current entity.
-    const unrelatedEvents: Types.Events.Event[] = [];
-    currentEntityEvents?.forEach(e => {
-      const cf = Helpers.Trace.getStackTraceTopCallFrameInEventPayload(e);
-
-      const matchesCallFrame = cf && Helpers.Trace.isMatchingCallFrame(cf, callFrame);
-      if (matchesCallFrame) {
-        sourceLocationEvents.push(e);
-      } else {
-        unrelatedEvents.push(e);
-      }
-    });
-    // Update current entity.
-    this.#entityMappings.eventsByEntity.set(currentEntity, unrelatedEvents);
-    // Map the source location events to the new entity.
-    this.#entityMappings.eventsByEntity.set(resolvedEntity, sourceLocationEvents);
-    sourceLocationEvents.forEach(e => {
-      this.#entityMappings.entityByEvent.set(e, resolvedEntity);
-    });
-    // Update our CallFrame cache when we've got a resolved entity.
-    this.#resolvedCallFrames.add(callFrame);
-  }
-
-  // Update entities with proper Chrome Extension names.
-  updateExtensionEntitiesWithName(executionContextNamesByOrigin: Map<Platform.DevToolsPath.UrlString, string>): void {
-    const entities = Array.from(this.#entityMappings.eventsByEntity.keys());
-    for (const [origin, name] of executionContextNamesByOrigin) {
-      // In makeUpChromeExtensionEntity, the extension origin is set as the only domain for the entity.
-      const entity = entities.find(e => e.domains[0] === origin);
-      if (entity) {
-        entity.name = entity.company = name;
-      }
-    }
-  }
-}

package/lib/front_end/models/trace/EventsSerializer.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 * as Helpers from './helpers/helpers.js';
-import type {ParsedTrace} from './ModelImpl.js';
-import * as Types from './types/types.js';
-
-export class EventsSerializer {
-  #modifiedProfileCallByKey = new Map<Types.File.ProfileCallKeyValues, Types.Events.SyntheticProfileCall>();
-
-  keyForEvent(event: Types.Events.Event): Types.File.SerializableKey|null {
-    if (Types.Events.isProfileCall(event)) {
-      return `${Types.File.EventKeyType.PROFILE_CALL}-${event.pid}-${event.tid}-${
-          Types.Events.SampleIndex(event.sampleIndex)}-${event.nodeId}`;
-    }
-
-    if (Types.Events.isLegacyTimelineFrame(event)) {
-      return `${Types.File.EventKeyType.LEGACY_TIMELINE_FRAME}-${event.index}`;
-    }
-
-    const rawEvents = Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager().getRawTraceEvents();
-    const key: Types.File.SyntheticEventKey|Types.File.RawEventKey = Types.Events.isSyntheticBased(event) ?
-        `${Types.File.EventKeyType.SYNTHETIC_EVENT}-${rawEvents.indexOf(event.rawSourceEvent)}` :
-        `${Types.File.EventKeyType.RAW_EVENT}-${rawEvents.indexOf(event)}`;
-    if (key.length < 3) {
-      return null;
-    }
-    return key;
-  }
-
-  eventForKey(key: Types.File.SerializableKey, parsedTrace: ParsedTrace): Types.Events.Event {
-    const eventValues = Types.File.traceEventKeyToValues(key);
-
-    if (EventsSerializer.isProfileCallKey(eventValues)) {
-      return this.#getModifiedProfileCallByKeyValues(eventValues, parsedTrace);
-    }
-
-    if (EventsSerializer.isLegacyTimelineFrameKey(eventValues)) {
-      const event = parsedTrace.data.Frames.frames.at(eventValues.rawIndex);
-      if (!event) {
-        throw new Error(`Unknown trace event. Could not find frame with index ${eventValues.rawIndex}`);
-      }
-      return event;
-    }
-
-    if (EventsSerializer.isSyntheticEventKey(eventValues)) {
-      const syntheticEvents = Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager().getSyntheticTraces();
-      const syntheticEvent = syntheticEvents.at(eventValues.rawIndex);
-      if (!syntheticEvent) {
-        throw new Error(`Unknown trace event. Attempted to get a synthetic event from an unknown raw event index: ${
-            eventValues.rawIndex}`);
-      }
-      return syntheticEvent;
-    }
-
-    if (EventsSerializer.isRawEventKey(eventValues)) {
-      const rawEvents = Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager().getRawTraceEvents();
-      return rawEvents[eventValues.rawIndex];
-    }
-    throw new Error(`Unknown trace event. Serializable key values: ${(eventValues as unknown[]).join('-')}`);
-  }
-
-  static isProfileCallKey(key: Types.File.SerializableKeyValues): key is Types.File.ProfileCallKeyValues {
-    return key.type === Types.File.EventKeyType.PROFILE_CALL;
-  }
-  static isLegacyTimelineFrameKey(key: Types.File.SerializableKeyValues):
-      key is Types.File.LegacyTimelineFrameKeyValues {
-    return key.type === Types.File.EventKeyType.LEGACY_TIMELINE_FRAME;
-  }
-
-  static isRawEventKey(key: Types.File.SerializableKeyValues): key is Types.File.RawEventKeyValues {
-    return key.type === Types.File.EventKeyType.RAW_EVENT;
-  }
-  static isSyntheticEventKey(key: Types.File.SerializableKeyValues): key is Types.File.SyntheticEventKeyValues {
-    return key.type === Types.File.EventKeyType.SYNTHETIC_EVENT;
-  }
-
-  #getModifiedProfileCallByKeyValues(key: Types.File.ProfileCallKeyValues, parsedTrace: ParsedTrace):
-      Types.Events.SyntheticProfileCall {
-    const cacheResult = this.#modifiedProfileCallByKey.get(key);
-    if (cacheResult) {
-      return cacheResult;
-    }
-    const profileCallsInThread =
-        parsedTrace.data.Renderer.processes.get(key.processID)?.threads.get(key.threadID)?.profileCalls;
-    if (!profileCallsInThread) {
-      throw new Error(`Unknown profile call serializable key: ${(key)}`);
-    }
-
-    const match = profileCallsInThread?.find((e: Types.Events.SyntheticProfileCall) => {
-      return e.sampleIndex === key.sampleIndex && e.nodeId === key.protocol;
-    });
-    if (!match) {
-      throw new Error(`Unknown profile call serializable key: ${(JSON.stringify(key))}`);
-    }
-    // Cache to avoid looking up in subsequent calls.
-    this.#modifiedProfileCallByKey.set(key, match);
-    return match;
-  }
-}