devtools-tracing 1.0.0

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

@@ -0,0 +1,180 @@
+// 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.
+
+export interface Progress {
+  totalWork: number;
+  worked: number;
+  title: string|undefined;
+  canceled: boolean;
+  done: boolean;
+}
+
+export class Progress implements Progress {
+  totalWork = 0;
+  worked = 0;
+  title: string|undefined = undefined;
+  canceled = false;
+  done = false;
+}
+
+export class CompositeProgress {
+  readonly parent: Progress;
+  readonly #children: SubProgress[];
+  #childrenDone: number;
+
+  constructor(parent: Progress) {
+    this.parent = parent;
+    this.#children = [];
+    this.#childrenDone = 0;
+    this.parent.totalWork = 1;
+    this.parent.worked = 0;
+  }
+
+  childDone(): void {
+    if (++this.#childrenDone !== this.#children.length) {
+      return;
+    }
+    this.parent.done = true;
+  }
+
+  createSubProgress(weight?: number): SubProgress {
+    const child = new SubProgress(this, weight);
+    this.#children.push(child);
+    return child;
+  }
+
+  update(): void {
+    let totalWeights = 0;
+    let done = 0;
+
+    for (let i = 0; i < this.#children.length; ++i) {
+      const child = this.#children[i];
+      if (child.totalWork) {
+        done += child.weight * child.worked / child.totalWork;
+      }
+      totalWeights += child.weight;
+    }
+    this.parent.worked = done / totalWeights;
+  }
+}
+
+export class SubProgress implements Progress {
+  readonly #composite: CompositeProgress;
+  #weight: number;
+  #worked: number;
+  #totalWork: number;
+  constructor(composite: CompositeProgress, weight?: number) {
+    this.#composite = composite;
+    this.#weight = weight || 1;
+    this.#worked = 0;
+
+    this.#totalWork = 0;
+  }
+
+  get canceled(): boolean {
+    return this.#composite.parent.canceled;
+  }
+
+  set title(title: string) {
+    this.#composite.parent.title = title;
+  }
+
+  set done(done: boolean) {
+    if (!done) {
+      return;
+    }
+    this.worked = this.#totalWork;
+    this.#composite.childDone();
+  }
+
+  set totalWork(totalWork: number) {
+    this.#totalWork = totalWork;
+    this.#composite.update();
+  }
+
+  set worked(worked: number) {
+    this.#worked = worked;
+    this.#composite.update();
+  }
+
+  get weight(): number {
+    return this.#weight;
+  }
+
+  get worked(): number {
+    return this.#worked;
+  }
+
+  get totalWork(): number {
+    return this.#totalWork;
+  }
+}
+
+export class ProgressProxy implements Progress {
+  readonly #delegate: Progress|null|undefined;
+  readonly #doneCallback: (() => void)|undefined;
+  readonly #updateCallback: (() => void)|undefined;
+
+  constructor(delegate?: Progress|null, doneCallback?: (() => void), updateCallback?: (() => void)) {
+    this.#delegate = delegate;
+    this.#doneCallback = doneCallback;
+    this.#updateCallback = updateCallback;
+  }
+
+  get canceled(): boolean {
+    return this.#delegate ? this.#delegate.canceled : false;
+  }
+
+  set title(title: string) {
+    if (this.#delegate) {
+      this.#delegate.title = title;
+    }
+    if (this.#updateCallback) {
+      this.#updateCallback();
+    }
+  }
+
+  get title(): string {
+    return this.#delegate?.title ?? '';
+  }
+
+  set done(done: boolean) {
+    if (this.#delegate) {
+      this.#delegate.done = done;
+    }
+    if (done && this.#doneCallback) {
+      this.#doneCallback();
+    }
+  }
+
+  get done(): boolean {
+    return this.#delegate ? this.#delegate.done : false;
+  }
+
+  set totalWork(totalWork: number) {
+    if (this.#delegate) {
+      this.#delegate.totalWork = totalWork;
+    }
+    if (this.#updateCallback) {
+      this.#updateCallback();
+    }
+  }
+
+  get totalWork(): number {
+    return this.#delegate ? this.#delegate.totalWork : 0;
+  }
+
+  set worked(worked: number) {
+    if (this.#delegate) {
+      this.#delegate.worked = worked;
+    }
+    if (this.#updateCallback) {
+      this.#updateCallback?.();
+    }
+  }
+
+  get worked(): number {
+    return this.#delegate ? this.#delegate.worked : 0;
+  }
+}

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

@@ -0,0 +1,7 @@
+// 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.
+
+export interface QueryParamHandler {
+  handleQueryParam(value: string): void;
+}

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

@@ -0,0 +1,85 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+interface PromiseInfo<T> {
+  promise: Promise<T>;
+  resolve: (obj: T) => void;
+  reject: (error: Error) => void;
+}
+
+/**
+ * A class that facilitates resolving a id to an object of type T. If the id does not yet resolve, a promise
+ * is created that gets resolved once `onResolve` is called with the corresponding id.
+ *
+ * This class enables clients to control the duration of the wait and the lifetime of the associated
+ * promises by using the `clear` method on this class.
+ */
+export abstract class ResolverBase<Id, T> {
+  #unresolvedIds = new Map<Id, PromiseInfo<T>>();
+
+  protected abstract getForId(id: Id): T|null;
+  protected abstract startListening(): void;
+  protected abstract stopListening(): void;
+
+  /**
+   * Returns a promise that resolves once the `id` can be resolved to an object.
+   */
+  async waitFor(id: Id): Promise<T> {
+    const obj = this.getForId(id);
+    if (!obj) {
+      return await this.getOrCreatePromise(id);
+    }
+    return obj;
+  }
+
+  /**
+   * Resolve the `id`. Returns the object immediately if it can be resolved,
+   * and otherwise waits for the object to appear and calls `callback` once
+   * it is resolved.
+   */
+  tryGet(id: Id, callback: (t: T) => void): T|null {
+    const obj = this.getForId(id);
+    if (!obj) {
+      const swallowTheError = (): void => {};
+      void this.getOrCreatePromise(id).catch(swallowTheError).then(obj => {
+        if (obj) {
+          callback(obj);
+        }
+      });
+      return null;
+    }
+    return obj;
+  }
+
+  /**
+   * Aborts all waiting and rejects all unresolved promises.
+   */
+  clear(): void {
+    this.stopListening();
+    for (const [id, {reject}] of this.#unresolvedIds.entries()) {
+      reject(new Error(`Object with ${id} never resolved.`));
+    }
+    this.#unresolvedIds.clear();
+  }
+
+  private getOrCreatePromise(id: Id): Promise<T> {
+    const promiseInfo = this.#unresolvedIds.get(id);
+    if (promiseInfo) {
+      return promiseInfo.promise;
+    }
+    const {resolve, reject, promise} = Promise.withResolvers<T>();
+    this.#unresolvedIds.set(id, {promise, resolve, reject});
+    this.startListening();
+    return promise;
+  }
+
+  protected onResolve(id: Id, t: T): void {
+    const promiseInfo = this.#unresolvedIds.get(id);
+    this.#unresolvedIds.delete(id);
+    if (this.#unresolvedIds.size === 0) {
+      this.stopListening();
+    }
+    promiseInfo?.resolve(t);
+  }
+}