devtools-tracing 1.0.0

package/lib/front_end/core/common/SimpleHistoryManager.ts

@@ -0,0 +1,124 @@
+// 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.
+
+export interface HistoryEntry {
+  valid(): boolean;
+
+  reveal(): void;
+}
+
+export class SimpleHistoryManager {
+  #entries: HistoryEntry[];
+  #activeEntryIndex: number;
+  #coalescingReadonly: number;
+  readonly #historyDepth: number;
+  constructor(historyDepth: number) {
+    this.#entries = [];
+    this.#activeEntryIndex = -1;
+
+    // Lock is used to make sure that reveal() does not
+    // make any changes to the history while we are
+    // rolling back or rolling over.
+    this.#coalescingReadonly = 0;
+    this.#historyDepth = historyDepth;
+  }
+
+  private readOnlyLock(): void {
+    ++this.#coalescingReadonly;
+  }
+
+  private releaseReadOnlyLock(): void {
+    --this.#coalescingReadonly;
+  }
+
+  private getPreviousValidIndex(): number {
+    if (this.empty()) {
+      return -1;
+    }
+
+    let revealIndex = this.#activeEntryIndex - 1;
+    while (revealIndex >= 0 && !this.#entries[revealIndex].valid()) {
+      --revealIndex;
+    }
+    if (revealIndex < 0) {
+      return -1;
+    }
+
+    return revealIndex;
+  }
+
+  private getNextValidIndex(): number {
+    let revealIndex = this.#activeEntryIndex + 1;
+
+    while (revealIndex < this.#entries.length && !this.#entries[revealIndex].valid()) {
+      ++revealIndex;
+    }
+    if (revealIndex >= this.#entries.length) {
+      return -1;
+    }
+
+    return revealIndex;
+  }
+
+  private readOnly(): boolean {
+    return Boolean(this.#coalescingReadonly);
+  }
+
+  empty(): boolean {
+    return !this.#entries.length;
+  }
+
+  active(): HistoryEntry|null {
+    return this.empty() ? null : this.#entries[this.#activeEntryIndex];
+  }
+
+  push(entry: HistoryEntry): void {
+    if (this.readOnly()) {
+      return;
+    }
+    if (!this.empty()) {
+      this.#entries.splice(this.#activeEntryIndex + 1);
+    }
+    this.#entries.push(entry);
+    if (this.#entries.length > this.#historyDepth) {
+      this.#entries.shift();
+    }
+    this.#activeEntryIndex = this.#entries.length - 1;
+  }
+
+  canRollback(): boolean {
+    return this.getPreviousValidIndex() >= 0;
+  }
+
+  canRollover(): boolean {
+    return this.getNextValidIndex() >= 0;
+  }
+
+  rollback(): boolean {
+    const revealIndex = this.getPreviousValidIndex();
+    if (revealIndex === -1) {
+      return false;
+    }
+    this.readOnlyLock();
+    this.#activeEntryIndex = revealIndex;
+    this.#entries[revealIndex].reveal();
+    this.releaseReadOnlyLock();
+
+    return true;
+  }
+
+  rollover(): boolean {
+    const revealIndex = this.getNextValidIndex();
+    if (revealIndex === -1) {
+      return false;
+    }
+
+    this.readOnlyLock();
+    this.#activeEntryIndex = revealIndex;
+    this.#entries[revealIndex].reveal();
+    this.releaseReadOnlyLock();
+
+    return true;
+  }
+}

package/lib/front_end/core/common/StringOutputStream.ts

@@ -0,0 +1,26 @@
+// Copyright 2015 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export interface OutputStream {
+  write(data: string, endOfFile?: boolean): Promise<void>;
+  close(): Promise<void>;
+}
+
+export class StringOutputStream implements OutputStream {
+  #data: string;
+  constructor() {
+    this.#data = '';
+  }
+
+  async write(chunk: string): Promise<void> {
+    this.#data += chunk;
+  }
+
+  async close(): Promise<void> {
+  }
+
+  data(): string {
+    return this.#data;
+  }
+}

package/lib/front_end/core/common/TextDictionary.ts

@@ -0,0 +1,48 @@
+// Copyright 2013 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import {Trie} from './Trie.js';
+
+export class TextDictionary {
+  readonly words = new Map<string, number>();
+  readonly index = Trie.newStringTrie();
+
+  addWord(word: string): void {
+    let count = this.words.get(word) || 0;
+    ++count;
+    this.words.set(word, count);
+    this.index.add(word);
+  }
+
+  removeWord(word: string): void {
+    let count = this.words.get(word) || 0;
+    if (!count) {
+      return;
+    }
+    if (count === 1) {
+      this.words.delete(word);
+      this.index.remove(word);
+      return;
+    }
+    --count;
+    this.words.set(word, count);
+  }
+
+  wordsWithPrefix(prefix: string): string[] {
+    return this.index.words(prefix);
+  }
+
+  hasWord(word: string): boolean {
+    return this.words.has(word);
+  }
+
+  wordCount(word: string): number {
+    return this.words.get(word) || 0;
+  }
+
+  reset(): void {
+    this.words.clear();
+    this.index.clear();
+  }
+}

package/lib/front_end/core/common/Throttler.ts

@@ -0,0 +1,99 @@
+// 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.
+
+export class Throttler {
+  readonly #timeout: number;
+  #isRunningProcess: boolean;
+  #asSoonAsPossible: boolean;
+  #process: (() => (void|Promise<unknown>))|null;
+  #lastCompleteTime: number;
+  #scheduler = Promise.withResolvers<unknown>();
+  #processTimeout?: number;
+
+  constructor(timeout: number) {
+    this.#timeout = timeout;
+    this.#isRunningProcess = false;
+    this.#asSoonAsPossible = false;
+    this.#process = null;
+    this.#lastCompleteTime = 0;
+  }
+
+  #processCompleted(): void {
+    this.#lastCompleteTime = this.#getTime();
+    this.#isRunningProcess = false;
+    if (this.#process) {
+      this.#schedule(false);
+    }
+  }
+
+  get process(): (() => (void|Promise<unknown>))|null {
+    return this.#process;
+  }
+
+  get processCompleted(): Promise<unknown>|null {
+    return this.#process ? this.#scheduler.promise : null;
+  }
+
+  #onTimeout(): void {
+    this.#processTimeout = undefined;
+    this.#asSoonAsPossible = false;
+    this.#isRunningProcess = true;
+
+    void Promise.resolve()
+        .then(this.#process)
+        .catch(console.error.bind(console))
+        .then(this.#processCompleted.bind(this))
+        .then(this.#scheduler.resolve);
+    this.#scheduler = Promise.withResolvers();
+    this.#process = null;
+  }
+
+  async schedule(process: () => (void|Promise<unknown>), scheduling = Scheduling.DEFAULT): Promise<void> {
+    // Deliberately skip previous #process.
+    this.#process = process;
+
+    // Run the first scheduled task instantly.
+    const hasScheduledTasks = Boolean(this.#processTimeout) || this.#isRunningProcess;
+    const okToFire = this.#getTime() - this.#lastCompleteTime > this.#timeout;
+    const asSoonAsPossible = scheduling === Scheduling.AS_SOON_AS_POSSIBLE ||
+        (scheduling === Scheduling.DEFAULT && !hasScheduledTasks && okToFire);
+
+    const forceTimerUpdate = asSoonAsPossible && !this.#asSoonAsPossible;
+    this.#asSoonAsPossible = this.#asSoonAsPossible || asSoonAsPossible;
+
+    this.#schedule(forceTimerUpdate);
+
+    await this.#scheduler.promise;
+  }
+
+  #schedule(forceTimerUpdate: boolean): void {
+    if (this.#isRunningProcess) {
+      return;
+    }
+    if (this.#processTimeout && !forceTimerUpdate) {
+      return;
+    }
+
+    clearTimeout(this.#processTimeout);
+
+    const timeout = this.#asSoonAsPossible ? 0 : this.#timeout;
+    this.#processTimeout = window.setTimeout(this.#onTimeout.bind(this), timeout);
+  }
+
+  #getTime(): number {
+    return window.performance.now();
+  }
+}
+
+export const enum Scheduling {
+  // If the throttler has run another task recently (i.e. time since the last run is less then the
+  // throttling delay), schedule the task to be run after the throttling delay. Otherwise scheule
+  // the task after the next tick.
+  DEFAULT = 'Default',
+  // Schedule the task to run at the next tick, even if the throttler has run another task recently.
+  AS_SOON_AS_POSSIBLE = 'AsSoonAsPossible',
+  // Schedule the task to run after the throttling delay, even if the throttler has not run any
+  // task recently.
+  DELAYED = 'Delayed',
+}

package/lib/front_end/core/common/Trie.ts

@@ -0,0 +1,152 @@
+// Copyright 2016 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Extracts the element type of an array like, eg:
+// ElementType<number[]> -> number
+// ElementTYpe<string> -> string
+type ElementType<T extends ArrayLike<unknown>> = T extends ArrayLike<infer E>? E : never;
+
+/**
+ * Abstracts some generic operations that have different implementations depending
+ * on whether we operate on strings or array of things.
+ **/
+interface TrieableTrait<T extends ArrayLike<ElementType<T>>> {
+  empty(): T;
+  append(base: T, appendage: ElementType<T>): T;
+  slice(base: T, start: number, end: number): T;
+}
+
+export class Trie<T extends ArrayLike<ElementType<T>>> {
+  #size!: number;
+  #root: number;
+  #edges!: Array<Map<ElementType<T>, number>>;
+  #isWord!: boolean[];
+  #wordsInSubtree!: number[];
+  #freeNodes!: number[];
+  #traitImpl: TrieableTrait<T>;
+
+  constructor(traitImpl: TrieableTrait<T>) {
+    this.#root = 0;
+    this.#traitImpl = traitImpl;
+    this.clear();
+  }
+
+  static newStringTrie(): Trie<string> {
+    return new Trie<string>({
+      empty: () => '',
+      append: (base, appendage) => base + appendage,
+      slice: (base, start, end) => base.slice(start, end),
+    });
+  }
+
+  static newArrayTrie<T extends Array<ElementType<T>>>(): Trie<Array<ElementType<T>>> {
+    return new Trie<Array<ElementType<T>>>({
+      empty: () => [],
+      append: (base, appendage) => base.concat([appendage]),
+      slice: (base, start, end) => base.slice(start, end),
+    });
+  }
+
+  add(word: T): void {
+    let node: number = this.#root;
+    ++this.#wordsInSubtree[this.#root];
+    for (let i = 0; i < word.length; ++i) {
+      const edge = word[i];
+      let next = this.#edges[node].get(edge);
+      if (!next) {
+        if (this.#freeNodes.length) {
+          next = (this.#freeNodes.pop() as number);
+        } else {
+          next = this.#size++;
+          this.#isWord.push(false);
+          this.#wordsInSubtree.push(0);
+          this.#edges.push(new Map());
+        }
+        this.#edges[node].set(edge, next);
+      }
+      ++this.#wordsInSubtree[next];
+      node = next;
+    }
+    this.#isWord[node] = true;
+  }
+
+  remove(word: T): boolean {
+    if (!this.has(word)) {
+      return false;
+    }
+    let node: number = this.#root;
+    --this.#wordsInSubtree[this.#root];
+    for (let i = 0; i < word.length; ++i) {
+      const edge = word[i];
+      const next = this.#edges[node].get(edge) as number;
+      if (!--this.#wordsInSubtree[next]) {
+        this.#edges[node].delete(edge);
+        this.#freeNodes.push(next);
+      }
+      node = next;
+    }
+    this.#isWord[node] = false;
+    return true;
+  }
+
+  has(word: T): boolean {
+    let node: number|undefined = this.#root;
+    for (let i = 0; i < word.length; ++i) {
+      node = this.#edges[node].get(word[i]);
+      if (!node) {
+        return false;
+      }
+    }
+    return this.#isWord[node];
+  }
+
+  words(prefix?: T): T[] {
+    prefix = prefix ?? this.#traitImpl.empty();
+    let node: number|undefined = this.#root;
+    for (let i = 0; i < prefix.length; ++i) {
+      node = this.#edges[node].get(prefix[i]);
+      if (!node) {
+        return [];
+      }
+    }
+    const results: T[] = [];
+    this.dfs(node, prefix, results);
+    return results;
+  }
+
+  private dfs(node: number, prefix: T, results: T[]): void {
+    if (this.#isWord[node]) {
+      results.push(prefix);
+    }
+    const edges = this.#edges[node];
+    for (const [edge, node] of edges) {
+      const newPrefix = this.#traitImpl.append(prefix, edge);
+      this.dfs(node, newPrefix, results);
+    }
+  }
+
+  longestPrefix(word: T, fullWordOnly: boolean): T {
+    let node: number|undefined = this.#root;
+    let wordIndex = 0;
+    for (let i = 0; i < word.length; ++i) {
+      node = this.#edges[node].get(word[i]);
+      if (!node) {
+        break;
+      }
+      if (!fullWordOnly || this.#isWord[node]) {
+        wordIndex = i + 1;
+      }
+    }
+    return this.#traitImpl.slice(word, 0, wordIndex);
+  }
+
+  clear(): void {
+    this.#size = 1;
+    this.#root = 0;
+    this.#edges = [new Map()];
+    this.#isWord = [false];
+    this.#wordsInSubtree = [0];
+    this.#freeNodes = [];
+  }
+}

package/lib/front_end/core/common/Worker.ts

@@ -0,0 +1,60 @@
+// 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.
+
+export class WorkerWrapper {
+  readonly #workerPromise: Promise<Worker>;
+  #disposed?: boolean;
+  #rejectWorkerPromise?: (error: Error) => void;
+
+  private constructor(workerLocation: URL) {
+    this.#workerPromise = new Promise((fulfill, reject) => {
+      this.#rejectWorkerPromise = reject;
+      const worker = new Worker(workerLocation, {type: 'module'});
+      worker.onerror = event => {
+        console.error(`Failed to load worker for ${workerLocation.href}:`, event);
+      };
+      worker.onmessage = (event: MessageEvent<unknown>) => {
+        console.assert(event.data === 'workerReady');
+        worker.onmessage = null;
+        fulfill(worker);
+      };
+    });
+  }
+
+  static fromURL(url: URL): WorkerWrapper {
+    return new WorkerWrapper(url);
+  }
+
+  postMessage(message: unknown, transfer?: Transferable[]): void {
+    void this.#workerPromise.then(worker => {
+      if (!this.#disposed) {
+        worker.postMessage(message, transfer ?? []);
+      }
+    });
+  }
+
+  dispose(): void {
+    this.#disposed = true;
+    void this.#workerPromise.then(worker => worker.terminate());
+  }
+
+  terminate(immediately = false): void {
+    if (immediately) {
+      this.#rejectWorkerPromise?.(new Error('Worker terminated'));
+    }
+    this.dispose();
+  }
+
+  set onmessage(listener: (event: MessageEvent) => void) {
+    void this.#workerPromise.then(worker => {
+      worker.onmessage = listener;
+    });
+  }
+
+  set onerror(listener: (event: Event) => void) {
+    void this.#workerPromise.then(worker => {
+      worker.onerror = listener;
+    });
+  }
+}

package/lib/front_end/core/common/common.ts

@@ -0,0 +1,81 @@
+// 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 App from './App.js';
+import * as AppProvider from './AppProvider.js';
+import * as Base64 from './Base64.js';
+import * as CharacterIdMap from './CharacterIdMap.js';
+import * as Color from './Color.js';
+import * as ColorConverter from './ColorConverter.js';
+import * as ColorUtils from './ColorUtils.js';
+import * as Console from './Console.js';
+import * as Debouncer from './Debouncer.js';
+import * as EventTarget from './EventTarget.js';
+import * as Gzip from './Gzip.js';
+import * as JavaScriptMetaData from './JavaScriptMetaData.js';
+import * as Lazy from './Lazy.js';
+import * as Linkifier from './Linkifier.js';
+import * as MapWithDefault from './MapWithDefault.js';
+import * as Mutex from './Mutex.js';
+import * as ObjectWrapper from './Object.js';
+import * as ParsedURL from './ParsedURL.js';
+import * as Progress from './Progress.js';
+import * as QueryParamHandler from './QueryParamHandler.js';
+import * as ResolverBase from './ResolverBase.js';
+import * as ResourceType from './ResourceType.js';
+import * as ReturnToPanel from './ReturnToPanel.js';
+import * as Revealer from './Revealer.js';
+import * as Runnable from './Runnable.js';
+import * as SegmentedRange from './SegmentedRange.js';
+import * as SettingRegistration from './SettingRegistration.js';
+import * as Settings from './Settings.js';
+import * as SimpleHistoryManager from './SimpleHistoryManager.js';
+import * as StringOutputStream from './StringOutputStream.js';
+import * as TextDictionary from './TextDictionary.js';
+import * as Throttler from './Throttler.js';
+import * as Trie from './Trie.js';
+import * as Worker from './Worker.js';
+
+/*
+ * This is re-exported here because we moved UIString into platform from
+ * common and wanted to avoid a huge rename of imports. A future CL will
+ * update all references to `Common.UIString` to `Platform.UIString`.
+ */
+export {UIString} from '../platform/platform.js';
+export {
+  App,
+  AppProvider,
+  Base64,
+  CharacterIdMap,
+  Color,
+  ColorConverter,
+  ColorUtils,
+  Console,
+  Debouncer,
+  EventTarget,
+  Gzip,
+  JavaScriptMetaData,
+  Lazy,
+  Linkifier,
+  MapWithDefault,
+  Mutex,
+  ObjectWrapper,
+  ParsedURL,
+  Progress,
+  QueryParamHandler,
+  ResolverBase,
+  ResourceType,
+  ReturnToPanel,
+  Revealer,
+  Runnable,
+  SegmentedRange,
+  SettingRegistration,
+  Settings,
+  SimpleHistoryManager,
+  StringOutputStream,
+  TextDictionary,
+  Throttler,
+  Trie,
+  Worker,
+};