devtools-tracing 1.0.1 → 1.1.1

package/lib/front_end/models/bindings/DefaultScriptMapping.ts

@@ -0,0 +1,141 @@
+// Copyright 2012 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 Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
+import * as SDK from '../../core/sdk/sdk.js';
+import type * as TextUtils from '../text_utils/text_utils.js';
+import * as Workspace from '../workspace/workspace.js';
+
+import {ContentProviderBasedProject} from './ContentProviderBasedProject.js';
+import type {DebuggerSourceMapping, DebuggerWorkspaceBinding} from './DebuggerWorkspaceBinding.js';
+
+export class DefaultScriptMapping implements DebuggerSourceMapping {
+  readonly #debuggerWorkspaceBinding: DebuggerWorkspaceBinding;
+  readonly #project: ContentProviderBasedProject;
+  readonly #eventListeners: Common.EventTarget.EventDescriptor[];
+  readonly #uiSourceCodeToScript: Map<Workspace.UISourceCode.UISourceCode, SDK.Script.Script>;
+  readonly #scriptToUISourceCode: Map<SDK.Script.Script, Workspace.UISourceCode.UISourceCode>;
+
+  constructor(
+      debuggerModel: SDK.DebuggerModel.DebuggerModel, workspace: Workspace.Workspace.WorkspaceImpl,
+      debuggerWorkspaceBinding: DebuggerWorkspaceBinding) {
+    defaultScriptMappings.add(this);
+    this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
+    this.#project = new ContentProviderBasedProject(
+        workspace, 'debugger:' + debuggerModel.target().id(), Workspace.Workspace.projectTypes.Debugger, '',
+        true /* isServiceProject */);
+    this.#eventListeners = [
+      debuggerModel.addEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, this.globalObjectCleared, this),
+      debuggerModel.addEventListener(SDK.DebuggerModel.Events.ParsedScriptSource, this.parsedScriptSource, this),
+      debuggerModel.addEventListener(
+          SDK.DebuggerModel.Events.DiscardedAnonymousScriptSource, this.discardedScriptSource, this),
+    ];
+    this.#uiSourceCodeToScript = new Map();
+    this.#scriptToUISourceCode = new Map();
+  }
+
+  static createV8ScriptURL(script: SDK.Script.Script): Platform.DevToolsPath.UrlString {
+    const name = Common.ParsedURL.ParsedURL.extractName(script.sourceURL);
+    const url = 'debugger:///VM' + script.scriptId + (name ? ' ' + name : '') as Platform.DevToolsPath.UrlString;
+    return url;
+  }
+
+  static scriptForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): SDK.Script.Script|null {
+    for (const defaultScriptMapping of defaultScriptMappings) {
+      const script = defaultScriptMapping.#uiSourceCodeToScript.get(uiSourceCode);
+      if (script !== undefined) {
+        return script;
+      }
+    }
+    return null;
+  }
+
+  uiSourceCodeForScript(script: SDK.Script.Script): Workspace.UISourceCode.UISourceCode|null {
+    return this.#scriptToUISourceCode.get(script) ?? null;
+  }
+
+  rawLocationToUILocation(rawLocation: SDK.DebuggerModel.Location): Workspace.UISourceCode.UILocation|null {
+    const script = rawLocation.script();
+    if (!script) {
+      return null;
+    }
+    const uiSourceCode = this.#scriptToUISourceCode.get(script);
+    if (!uiSourceCode) {
+      return null;
+    }
+    const {lineNumber, columnNumber} = script.rawLocationToRelativeLocation(rawLocation);
+    return uiSourceCode.uiLocation(lineNumber, columnNumber);
+  }
+
+  uiLocationToRawLocations(
+      uiSourceCode: Workspace.UISourceCode.UISourceCode, lineNumber: number,
+      columnNumber?: number): SDK.DebuggerModel.Location[] {
+    const script = this.#uiSourceCodeToScript.get(uiSourceCode);
+    if (!script) {
+      return [];
+    }
+    ({lineNumber, columnNumber} = script.relativeLocationToRawLocation({lineNumber, columnNumber}));
+    return [script.debuggerModel.createRawLocation(script, lineNumber, columnNumber ?? 0)];
+  }
+
+  uiLocationRangeToRawLocationRanges(
+      uiSourceCode: Workspace.UISourceCode.UISourceCode,
+      {startLine, startColumn, endLine, endColumn}: TextUtils.TextRange.TextRange):
+      SDK.DebuggerModel.LocationRange[]|null {
+    const script = this.#uiSourceCodeToScript.get(uiSourceCode);
+    if (!script) {
+      return [];
+    }
+    ({lineNumber: startLine, columnNumber: startColumn} =
+         script.relativeLocationToRawLocation({lineNumber: startLine, columnNumber: startColumn}));
+    ({lineNumber: endLine, columnNumber: endColumn} =
+         script.relativeLocationToRawLocation({lineNumber: endLine, columnNumber: endColumn}));
+    const start = script.debuggerModel.createRawLocation(script, startLine, startColumn);
+    const end = script.debuggerModel.createRawLocation(script, endLine, endColumn);
+    return [{start, end}];
+  }
+
+  private parsedScriptSource(event: Common.EventTarget.EventTargetEvent<SDK.Script.Script>): void {
+    const script = event.data;
+    const url = DefaultScriptMapping.createV8ScriptURL(script);
+
+    const uiSourceCode = this.#project.createUISourceCode(url, Common.ResourceType.resourceTypes.Script);
+    if (script.isBreakpointCondition) {
+      uiSourceCode.markAsUnconditionallyIgnoreListed();
+    }
+    this.#uiSourceCodeToScript.set(uiSourceCode, script);
+    this.#scriptToUISourceCode.set(script, uiSourceCode);
+    this.#project.addUISourceCodeWithProvider(uiSourceCode, script, null, 'text/javascript');
+    void this.#debuggerWorkspaceBinding.updateLocations(script);
+  }
+
+  private discardedScriptSource(event: Common.EventTarget.EventTargetEvent<SDK.Script.Script>): void {
+    const script = event.data;
+    const uiSourceCode = this.#scriptToUISourceCode.get(script);
+    if (uiSourceCode === undefined) {
+      return;
+    }
+    this.#scriptToUISourceCode.delete(script);
+    this.#uiSourceCodeToScript.delete(uiSourceCode);
+    this.#project.removeUISourceCode(uiSourceCode.url());
+  }
+
+  private globalObjectCleared(): void {
+    this.#scriptToUISourceCode.clear();
+    this.#uiSourceCodeToScript.clear();
+    this.#project.reset();
+  }
+
+  dispose(): void {
+    defaultScriptMappings.delete(this);
+    Common.EventTarget.removeEventListeners(this.#eventListeners);
+    this.globalObjectCleared();
+    this.#project.dispose();
+  }
+}
+
+// TODO(bmeurer): Remove the static methods from DefaultScriptMapping
+// and get rid of this global table.
+const defaultScriptMappings = new Set<DefaultScriptMapping>();

package/lib/front_end/models/bindings/FileUtils.ts

@@ -0,0 +1,228 @@
+// Copyright 2012 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 Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
+import * as TextUtils from '../text_utils/text_utils.js';
+import * as Workspace from '../workspace/workspace.js';
+
+export interface ChunkedReader {
+  fileSize(): number;
+
+  loadedSize(): number;
+
+  fileName(): string;
+
+  cancel(): void;
+
+  error(): DOMError|null;
+}
+
+export class ChunkedFileReader implements ChunkedReader {
+  #file: File|null;
+  readonly #fileSize: number;
+  #loadedSize: number;
+  #streamReader: ReadableStreamDefaultReader<Uint8Array<ArrayBuffer>>|null;
+  readonly #chunkSize: number;
+  readonly #chunkTransferredCallback: ((arg0: ChunkedReader) => void)|undefined;
+  readonly #decoder: TextDecoder;
+  #isCanceled: boolean;
+  #error: DOMException|null;
+  #transferFinished!: (arg0: boolean) => void;
+  #output?: Common.StringOutputStream.OutputStream;
+  #reader?: FileReader|null;
+
+  constructor(file: File, chunkSize?: number, chunkTransferredCallback?: ((arg0: ChunkedReader) => void)) {
+    this.#file = file;
+    this.#fileSize = file.size;
+    this.#loadedSize = 0;
+    this.#chunkSize = (chunkSize) ? chunkSize : Number.MAX_VALUE;
+    this.#chunkTransferredCallback = chunkTransferredCallback;
+    this.#decoder = new TextDecoder();
+    this.#isCanceled = false;
+    this.#error = null;
+    this.#streamReader = null;
+  }
+
+  async read(output: Common.StringOutputStream.OutputStream): Promise<boolean> {
+    if (this.#chunkTransferredCallback) {
+      this.#chunkTransferredCallback(this);
+    }
+
+    if (this.#file?.type.endsWith('gzip')) {
+      const fileStream = this.#file.stream();
+      const stream = Common.Gzip.decompressStream(fileStream);
+      this.#streamReader = stream.getReader();
+    } else {
+      this.#reader = new FileReader();
+      this.#reader.onload = this.onChunkLoaded.bind(this);
+      this.#reader.onerror = this.onError.bind(this);
+    }
+
+    this.#output = output;
+    void this.loadChunk();
+
+    return await new Promise(resolve => {
+      this.#transferFinished = resolve;
+    });
+  }
+
+  cancel(): void {
+    this.#isCanceled = true;
+  }
+
+  loadedSize(): number {
+    return this.#loadedSize;
+  }
+
+  fileSize(): number {
+    return this.#fileSize;
+  }
+
+  fileName(): string {
+    if (!this.#file) {
+      return '';
+    }
+    return this.#file.name;
+  }
+
+  error(): DOMException|null {
+    return this.#error;
+  }
+
+  private onChunkLoaded(event: Event): void {
+    if (this.#isCanceled) {
+      return;
+    }
+
+    const eventTarget = (event.target as FileReader);
+    if (eventTarget.readyState !== FileReader.DONE) {
+      return;
+    }
+
+    if (!this.#reader) {
+      return;
+    }
+
+    const buffer = (this.#reader.result as ArrayBuffer);
+    this.#loadedSize += buffer.byteLength;
+    const endOfFile = this.#loadedSize === this.#fileSize;
+    void this.decodeChunkBuffer(buffer, endOfFile);
+  }
+
+  private async decodeChunkBuffer(buffer: ArrayBuffer, endOfFile: boolean): Promise<void> {
+    if (!this.#output) {
+      return;
+    }
+    const decodedString = this.#decoder.decode(buffer, {stream: !endOfFile});
+    await this.#output.write(decodedString, endOfFile);
+    if (this.#isCanceled) {
+      return;
+    }
+    if (this.#chunkTransferredCallback) {
+      this.#chunkTransferredCallback(this);
+    }
+
+    if (endOfFile) {
+      void this.finishRead();
+      return;
+    }
+    void this.loadChunk();
+  }
+
+  private async finishRead(): Promise<void> {
+    if (!this.#output) {
+      return;
+    }
+    this.#file = null;
+    this.#reader = null;
+    await this.#output.close();
+    this.#transferFinished(!this.#error);
+  }
+
+  private async loadChunk(): Promise<void> {
+    if (!this.#output || !this.#file) {
+      return;
+    }
+    if (this.#streamReader) {
+      const {value, done} = await this.#streamReader.read();
+      if (done || !value) {
+        // Write empty string to inform of file end
+        await this.#output.write('', true);
+        return await this.finishRead();
+      }
+      void this.decodeChunkBuffer(value.buffer, false);
+    }
+    if (this.#reader) {
+      const chunkStart = this.#loadedSize;
+      const chunkEnd = Math.min(this.#fileSize, chunkStart + this.#chunkSize);
+      const nextPart = this.#file.slice(chunkStart, chunkEnd);
+      this.#reader.readAsArrayBuffer(nextPart);
+    }
+  }
+
+  private onError(event: Event): void {
+    const eventTarget = (event.target as FileReader);
+    this.#error = eventTarget.error;
+    this.#transferFinished(false);
+  }
+}
+
+export class FileOutputStream implements Common.StringOutputStream.OutputStream {
+  #writeCallbacks: Array<() => void>;
+  #fileName!: Platform.DevToolsPath.RawPathString|Platform.DevToolsPath.UrlString;
+  #closed?: boolean;
+  constructor() {
+    this.#writeCallbacks = [];
+  }
+
+  async open(fileName: Platform.DevToolsPath.RawPathString|Platform.DevToolsPath.UrlString): Promise<boolean> {
+    this.#closed = false;
+    this.#writeCallbacks = [];
+    this.#fileName = fileName;
+    const saveResponse = await Workspace.FileManager.FileManager.instance().save(
+        this.#fileName, TextUtils.ContentData.EMPTY_TEXT_CONTENT_DATA, /* forceSaveAs=*/ true);
+    if (saveResponse) {
+      Workspace.FileManager.FileManager.instance().addEventListener(
+          Workspace.FileManager.Events.APPENDED_TO_URL, this.onAppendDone, this);
+    }
+    return Boolean(saveResponse);
+  }
+
+  write(data: string): Promise<void> {
+    return new Promise(resolve => {
+      this.#writeCallbacks.push(resolve);
+      Workspace.FileManager.FileManager.instance().append(this.#fileName, data);
+    });
+  }
+
+  async close(): Promise<void> {
+    this.#closed = true;
+    if (this.#writeCallbacks.length) {
+      return;
+    }
+    Workspace.FileManager.FileManager.instance().removeEventListener(
+        Workspace.FileManager.Events.APPENDED_TO_URL, this.onAppendDone, this);
+    Workspace.FileManager.FileManager.instance().close(this.#fileName);
+  }
+
+  private onAppendDone(event: Common.EventTarget.EventTargetEvent<string>): void {
+    if (event.data !== this.#fileName) {
+      return;
+    }
+    const writeCallback = this.#writeCallbacks.shift();
+    if (writeCallback) {
+      writeCallback();
+    }
+    if (this.#writeCallbacks.length) {
+      return;
+    }
+    if (!this.#closed) {
+      return;
+    }
+    Workspace.FileManager.FileManager.instance().removeEventListener(
+        Workspace.FileManager.Events.APPENDED_TO_URL, this.onAppendDone, this);
+    Workspace.FileManager.FileManager.instance().close(this.#fileName);
+  }
+}

package/lib/front_end/models/bindings/LiveLocation.ts

@@ -0,0 +1,81 @@
+// Copyright 2014 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 Workspace from '../workspace/workspace.js';
+
+export interface LiveLocation {
+  update(): Promise<void>;
+  uiLocation(): Promise<Workspace.UISourceCode.UILocation|null>;
+  dispose(): void;
+  isDisposed(): boolean;
+}
+
+export class LiveLocationWithPool implements LiveLocation {
+  #updateDelegate: ((arg0: LiveLocation) => Promise<void>)|null;
+  readonly #locationPool: LiveLocationPool;
+  #updatePromise: Promise<void>|null;
+
+  constructor(updateDelegate: (arg0: LiveLocation) => Promise<void>, locationPool: LiveLocationPool) {
+    this.#updateDelegate = updateDelegate;
+    this.#locationPool = locationPool;
+    this.#locationPool.add(this);
+
+    this.#updatePromise = null;
+  }
+
+  async update(): Promise<void> {
+    if (!this.#updateDelegate) {
+      return;
+    }
+    // The following is a basic scheduling algorithm, guaranteeing that
+    // {#updateDelegate} is always run atomically. That is, we always
+    // wait for an update to finish before we trigger the next run.
+    if (this.#updatePromise) {
+      await this.#updatePromise.then(() => this.update());
+    } else {
+      this.#updatePromise = this.#updateDelegate(this);
+      await this.#updatePromise;
+      this.#updatePromise = null;
+    }
+  }
+
+  async uiLocation(): Promise<Workspace.UISourceCode.UILocation|null> {
+    throw new Error('Not implemented');
+  }
+
+  dispose(): void {
+    this.#locationPool.delete(this);
+    this.#updateDelegate = null;
+  }
+
+  isDisposed(): boolean {
+    return !this.#locationPool.has(this);
+  }
+}
+
+export class LiveLocationPool {
+  readonly #locations: Set<LiveLocation>;
+
+  constructor() {
+    this.#locations = new Set();
+  }
+
+  add(location: LiveLocation): void {
+    this.#locations.add(location);
+  }
+
+  delete(location: LiveLocation): void {
+    this.#locations.delete(location);
+  }
+
+  has(location: LiveLocation): boolean {
+    return this.#locations.has(location);
+  }
+
+  disposeAll(): void {
+    for (const location of this.#locations) {
+      location.dispose();
+    }
+  }
+}

package/lib/front_end/models/bindings/NetworkProject.ts

@@ -0,0 +1,157 @@
+// Copyright 2012 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 Common from '../../core/common/common.js';
+import * as SDK from '../../core/sdk/sdk.js';
+import type * as Protocol from '../../generated/protocol.js';
+import type * as Workspace from '../workspace/workspace.js';
+
+const uiSourceCodeToAttributionMap = new WeakMap<Workspace.UISourceCode.UISourceCode, Map<Protocol.Page.FrameId, {
+                                                   frame: SDK.ResourceTreeModel.ResourceTreeFrame,
+                                                   count: number,
+                                                 }>>();
+const projectToTargetMap = new WeakMap<Workspace.Workspace.Project, SDK.Target.Target>();
+
+let networkProjectManagerInstance: NetworkProjectManager;
+
+export class NetworkProjectManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  private constructor() {
+    super();
+  }
+
+  static instance({forceNew}: {
+    forceNew: boolean,
+  } = {forceNew: false}): NetworkProjectManager {
+    if (!networkProjectManagerInstance || forceNew) {
+      networkProjectManagerInstance = new NetworkProjectManager();
+    }
+
+    return networkProjectManagerInstance;
+  }
+}
+
+export const enum Events {
+  FRAME_ATTRIBUTION_ADDED = 'FrameAttributionAdded',
+  FRAME_ATTRIBUTION_REMOVED = 'FrameAttributionRemoved',
+}
+
+export interface FrameAttributionEvent {
+  uiSourceCode: Workspace.UISourceCode.UISourceCode;
+  frame: SDK.ResourceTreeModel.ResourceTreeFrame;
+}
+
+export interface EventTypes {
+  [Events.FRAME_ATTRIBUTION_ADDED]: FrameAttributionEvent;
+  [Events.FRAME_ATTRIBUTION_REMOVED]: FrameAttributionEvent;
+}
+
+export class NetworkProject {
+  static resolveFrame(uiSourceCode: Workspace.UISourceCode.UISourceCode, frameId: Protocol.Page.FrameId):
+      SDK.ResourceTreeModel.ResourceTreeFrame|null {
+    const target = NetworkProject.targetForUISourceCode(uiSourceCode);
+    const resourceTreeModel = target?.model(SDK.ResourceTreeModel.ResourceTreeModel);
+    return resourceTreeModel ? resourceTreeModel.frameForId(frameId) : null;
+  }
+
+  static setInitialFrameAttribution(uiSourceCode: Workspace.UISourceCode.UISourceCode, frameId: Protocol.Page.FrameId):
+      void {
+    if (!frameId) {
+      return;
+    }
+    const frame = NetworkProject.resolveFrame(uiSourceCode, frameId);
+    if (!frame) {
+      return;
+    }
+    const attribution = new Map<Protocol.Page.FrameId, {
+      frame: SDK.ResourceTreeModel.ResourceTreeFrame,
+      count: number,
+    }>();
+    attribution.set(frameId, {frame, count: 1});
+    uiSourceCodeToAttributionMap.set(uiSourceCode, attribution);
+  }
+
+  static cloneInitialFrameAttribution(
+      fromUISourceCode: Workspace.UISourceCode.UISourceCode,
+      toUISourceCode: Workspace.UISourceCode.UISourceCode): void {
+    const fromAttribution = uiSourceCodeToAttributionMap.get(fromUISourceCode);
+    if (!fromAttribution) {
+      return;
+    }
+    const toAttribution = new Map<Protocol.Page.FrameId, {
+      frame: SDK.ResourceTreeModel.ResourceTreeFrame,
+      count: number,
+    }>();
+    for (const frameId of fromAttribution.keys()) {
+      const value = fromAttribution.get(frameId);
+      if (typeof value !== 'undefined') {
+        toAttribution.set(frameId, {frame: value.frame, count: value.count});
+      }
+    }
+    uiSourceCodeToAttributionMap.set(toUISourceCode, toAttribution);
+  }
+
+  static addFrameAttribution(uiSourceCode: Workspace.UISourceCode.UISourceCode, frameId: Protocol.Page.FrameId): void {
+    const frame = NetworkProject.resolveFrame(uiSourceCode, frameId);
+    if (!frame) {
+      return;
+    }
+    const frameAttribution = uiSourceCodeToAttributionMap.get(uiSourceCode);
+    if (!frameAttribution) {
+      return;
+    }
+    const attributionInfo = frameAttribution.get(frameId) || {frame, count: 0};
+    attributionInfo.count += 1;
+    frameAttribution.set(frameId, attributionInfo);
+    if (attributionInfo.count !== 1) {
+      return;
+    }
+
+    const data = {uiSourceCode, frame};
+    NetworkProjectManager.instance().dispatchEventToListeners(Events.FRAME_ATTRIBUTION_ADDED, data);
+  }
+
+  static removeFrameAttribution(uiSourceCode: Workspace.UISourceCode.UISourceCode, frameId: Protocol.Page.FrameId):
+      void {
+    const frameAttribution = uiSourceCodeToAttributionMap.get(uiSourceCode);
+    if (!frameAttribution) {
+      return;
+    }
+    const attributionInfo = frameAttribution.get(frameId);
+    console.assert(Boolean(attributionInfo), 'Failed to remove frame attribution for url: ' + uiSourceCode.url());
+    if (!attributionInfo) {
+      return;
+    }
+    attributionInfo.count -= 1;
+    if (attributionInfo.count > 0) {
+      return;
+    }
+    frameAttribution.delete(frameId);
+    const data = {uiSourceCode, frame: attributionInfo.frame};
+    NetworkProjectManager.instance().dispatchEventToListeners(Events.FRAME_ATTRIBUTION_REMOVED, data);
+  }
+
+  static targetForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): SDK.Target.Target|null {
+    return projectToTargetMap.get(uiSourceCode.project()) || null;
+  }
+
+  static setTargetForProject(project: Workspace.Workspace.Project, target: SDK.Target.Target): void {
+    projectToTargetMap.set(project, target);
+  }
+
+  static getTargetForProject(project: Workspace.Workspace.Project): SDK.Target.Target|null {
+    return projectToTargetMap.get(project) || null;
+  }
+
+  static framesForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode):
+      SDK.ResourceTreeModel.ResourceTreeFrame[] {
+    const target = NetworkProject.targetForUISourceCode(uiSourceCode);
+    const resourceTreeModel = target?.model(SDK.ResourceTreeModel.ResourceTreeModel);
+    const attribution = uiSourceCodeToAttributionMap.get(uiSourceCode);
+    if (!resourceTreeModel || !attribution) {
+      return [];
+    }
+    const frames = Array.from(attribution.keys()).map(frameId => resourceTreeModel.frameForId(frameId));
+    return frames.filter(frame => !!frame);
+  }
+}