devtools-tracing 1.0.0

package/lib/front_end/core/sdk/StorageBucketsModel.ts

@@ -0,0 +1,204 @@
+// Copyright 2023 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 ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import type * as Common from '../common/common.js';
+
+import {SDKModel} from './SDKModel.js';
+import {Events as StorageKeyManagerEvents, StorageKeyManager} from './StorageKeyManager.js';
+import {Capability, type Target} from './Target.js';
+
+export class StorageBucketsModel extends SDKModel<EventTypes> implements ProtocolProxyApi.StorageDispatcher {
+  private enabled = false;
+  readonly storageAgent: ProtocolProxyApi.StorageApi;
+  private readonly storageKeyManager: StorageKeyManager|null;
+  private bucketsById = new Map<string, Protocol.Storage.StorageBucketInfo>();
+  private trackedStorageKeys = new Set<string>();
+
+  constructor(target: Target) {
+    super(target);
+    target.registerStorageDispatcher(this);
+    this.storageAgent = target.storageAgent();
+    this.storageKeyManager = target.model(StorageKeyManager);
+  }
+
+  getBuckets(): Set<Protocol.Storage.StorageBucketInfo> {
+    return new Set(this.bucketsById.values());
+  }
+
+  getBucketsForStorageKey(storageKey: string): Set<Protocol.Storage.StorageBucketInfo> {
+    const buckets = [...this.bucketsById.values()];
+    return new Set(buckets.filter(({bucket}) => bucket.storageKey === storageKey));
+  }
+
+  getDefaultBucketForStorageKey(storageKey: string): Protocol.Storage.StorageBucketInfo|null {
+    const buckets = [...this.bucketsById.values()];
+    return buckets.find(({bucket}) => bucket.storageKey === storageKey && bucket.name === undefined) ?? null;
+  }
+
+  getBucketById(bucketId: string): Protocol.Storage.StorageBucketInfo|null {
+    return this.bucketsById.get(bucketId) ?? null;
+  }
+
+  getBucketByName(storageKey: string, bucketName?: string): Protocol.Storage.StorageBucketInfo|null {
+    if (!bucketName) {
+      return this.getDefaultBucketForStorageKey(storageKey);
+    }
+    const buckets = [...this.bucketsById.values()];
+    return buckets.find(({bucket}) => bucket.storageKey === storageKey && bucket.name === bucketName) ?? null;
+  }
+
+  deleteBucket(bucket: Protocol.Storage.StorageBucket): void {
+    void this.storageAgent.invoke_deleteStorageBucket({bucket});
+  }
+
+  enable(): void {
+    if (this.enabled) {
+      return;
+    }
+
+    if (this.storageKeyManager) {
+      this.storageKeyManager.addEventListener(StorageKeyManagerEvents.STORAGE_KEY_ADDED, this.storageKeyAdded, this);
+      this.storageKeyManager.addEventListener(
+          StorageKeyManagerEvents.STORAGE_KEY_REMOVED, this.storageKeyRemoved, this);
+      for (const storageKey of this.storageKeyManager.storageKeys()) {
+        this.addStorageKey(storageKey);
+      }
+    }
+
+    this.enabled = true;
+  }
+
+  private storageKeyAdded(event: Common.EventTarget.EventTargetEvent<string>): void {
+    this.addStorageKey(event.data);
+  }
+  private storageKeyRemoved(event: Common.EventTarget.EventTargetEvent<string>): void {
+    this.removeStorageKey(event.data);
+  }
+
+  private addStorageKey(storageKey: string): void {
+    if (this.trackedStorageKeys.has(storageKey)) {
+      throw new Error('Can\'t call addStorageKey for a storage key if it has already been added.');
+    }
+
+    this.trackedStorageKeys.add(storageKey);
+    void this.storageAgent.invoke_setStorageBucketTracking({storageKey, enable: true});
+  }
+
+  private removeStorageKey(storageKey: string): void {
+    if (!this.trackedStorageKeys.has(storageKey)) {
+      throw new Error('Can\'t call removeStorageKey for a storage key if it hasn\'t already been added.');
+    }
+    const bucketsForStorageKey = this.getBucketsForStorageKey(storageKey);
+    for (const bucket of bucketsForStorageKey) {
+      this.bucketRemoved(bucket);
+    }
+    this.trackedStorageKeys.delete(storageKey);
+    void this.storageAgent.invoke_setStorageBucketTracking({storageKey, enable: false});
+  }
+
+  private bucketAdded(bucketInfo: Protocol.Storage.StorageBucketInfo): void {
+    this.bucketsById.set(bucketInfo.id, bucketInfo);
+    this.dispatchEventToListeners(Events.BUCKET_ADDED, {model: this, bucketInfo});
+  }
+
+  private bucketRemoved(bucketInfo: Protocol.Storage.StorageBucketInfo): void {
+    this.bucketsById.delete(bucketInfo.id);
+    this.dispatchEventToListeners(Events.BUCKET_REMOVED, {model: this, bucketInfo});
+  }
+
+  private bucketChanged(bucketInfo: Protocol.Storage.StorageBucketInfo): void {
+    this.dispatchEventToListeners(Events.BUCKET_CHANGED, {model: this, bucketInfo});
+  }
+
+  private bucketInfosAreEqual(
+      bucketInfo1: Protocol.Storage.StorageBucketInfo, bucketInfo2: Protocol.Storage.StorageBucketInfo): boolean {
+    return bucketInfo1.bucket.storageKey === bucketInfo2.bucket.storageKey && bucketInfo1.id === bucketInfo2.id &&
+        bucketInfo1.bucket.name === bucketInfo2.bucket.name && bucketInfo1.expiration === bucketInfo2.expiration &&
+        bucketInfo1.quota === bucketInfo2.quota && bucketInfo1.persistent === bucketInfo2.persistent &&
+        bucketInfo1.durability === bucketInfo2.durability;
+  }
+
+  storageBucketCreatedOrUpdated({bucketInfo}: Protocol.Storage.StorageBucketCreatedOrUpdatedEvent): void {
+    const curBucket = this.getBucketById(bucketInfo.id);
+    if (curBucket) {
+      if (!this.bucketInfosAreEqual(curBucket, bucketInfo)) {
+        this.bucketChanged(bucketInfo);
+      }
+    } else {
+      this.bucketAdded(bucketInfo);
+    }
+  }
+
+  storageBucketDeleted({bucketId}: Protocol.Storage.StorageBucketDeletedEvent): void {
+    const curBucket = this.getBucketById(bucketId);
+    if (curBucket) {
+      this.bucketRemoved(curBucket);
+    } else {
+      throw new Error(
+          `Received an event that Storage Bucket '${bucketId}' was deleted, but it wasn't in the StorageBucketsModel.`);
+    }
+  }
+
+  attributionReportingTriggerRegistered(_event: Protocol.Storage.AttributionReportingTriggerRegisteredEvent): void {
+  }
+
+  interestGroupAccessed(_event: Protocol.Storage.InterestGroupAccessedEvent): void {
+  }
+
+  interestGroupAuctionEventOccurred(_event: Protocol.Storage.InterestGroupAuctionEventOccurredEvent): void {
+  }
+
+  interestGroupAuctionNetworkRequestCreated(_event: Protocol.Storage.InterestGroupAuctionNetworkRequestCreatedEvent):
+      void {
+  }
+
+  indexedDBListUpdated(_event: Protocol.Storage.IndexedDBListUpdatedEvent): void {
+  }
+
+  indexedDBContentUpdated(_event: Protocol.Storage.IndexedDBContentUpdatedEvent): void {
+  }
+
+  cacheStorageListUpdated(_event: Protocol.Storage.CacheStorageListUpdatedEvent): void {
+  }
+
+  cacheStorageContentUpdated(_event: Protocol.Storage.CacheStorageContentUpdatedEvent): void {
+  }
+
+  sharedStorageAccessed(_event: Protocol.Storage.SharedStorageAccessedEvent): void {
+  }
+
+  sharedStorageWorkletOperationExecutionFinished(
+      _event: Protocol.Storage.SharedStorageWorkletOperationExecutionFinishedEvent): void {
+  }
+
+  attributionReportingSourceRegistered(_event: Protocol.Storage.AttributionReportingSourceRegisteredEvent): void {
+  }
+  attributionReportingReportSent(_event: Protocol.Storage.AttributionReportingReportSentEvent): void {
+  }
+
+  attributionReportingVerboseDebugReportSent(_event: Protocol.Storage.AttributionReportingVerboseDebugReportSentEvent):
+      void {
+  }
+}
+
+SDKModel.register(StorageBucketsModel, {capabilities: Capability.STORAGE, autostart: false});
+
+export const enum Events {
+  BUCKET_ADDED = 'BucketAdded',
+  BUCKET_REMOVED = 'BucketRemoved',
+  BUCKET_CHANGED = 'BucketChanged',
+}
+
+export interface BucketEvent {
+  model: StorageBucketsModel;
+  bucketInfo: Protocol.Storage.StorageBucketInfo;
+}
+
+export interface EventTypes {
+  [Events.BUCKET_ADDED]: BucketEvent;
+  [Events.BUCKET_REMOVED]: BucketEvent;
+  [Events.BUCKET_CHANGED]: BucketEvent;
+}

package/lib/front_end/core/sdk/StorageKeyManager.ts

@@ -0,0 +1,98 @@
+// Copyright 2022 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 '../common/common.js';
+import type * as Platform from '../platform/platform.js';
+
+import {SDKModel} from './SDKModel.js';
+import {Capability, type Target} from './Target.js';
+
+export class StorageKeyManager extends SDKModel<EventTypes> {
+  #mainStorageKey: string;
+  #storageKeys: Set<string>;
+  constructor(target: Target) {
+    super(target);
+
+    this.#mainStorageKey = '';
+    this.#storageKeys = new Set();
+  }
+
+  updateStorageKeys(storageKeys: Set<string>): void {
+    const oldStorageKeys = this.#storageKeys;
+    this.#storageKeys = storageKeys;
+
+    for (const storageKey of oldStorageKeys) {
+      if (!this.#storageKeys.has(storageKey)) {
+        this.dispatchEventToListeners(Events.STORAGE_KEY_REMOVED, storageKey);
+      }
+    }
+
+    for (const storageKey of this.#storageKeys) {
+      if (!oldStorageKeys.has(storageKey)) {
+        this.dispatchEventToListeners(Events.STORAGE_KEY_ADDED, storageKey);
+      }
+    }
+  }
+
+  storageKeys(): string[] {
+    return [...this.#storageKeys];
+  }
+
+  mainStorageKey(): string {
+    return this.#mainStorageKey;
+  }
+
+  setMainStorageKey(storageKey: string): void {
+    this.#mainStorageKey = storageKey;
+    this.dispatchEventToListeners(Events.MAIN_STORAGE_KEY_CHANGED, {
+      mainStorageKey: this.#mainStorageKey,
+    });
+  }
+}
+
+export function parseStorageKey(storageKeyString: string): StorageKey {
+  // Based on the canonical implementation of StorageKey::Deserialize in
+  // third_party/blink/common/storage_key/storage_key.cc
+  const components = storageKeyString.split('^');
+  const origin = Common.ParsedURL.ParsedURL.extractOrigin(components[0] as Platform.DevToolsPath.UrlString);
+  const storageKey = {origin, components: new Map<StorageKeyComponent, string>()};
+  for (let i = 1; i < components.length; ++i) {
+    storageKey.components.set(components[i].charAt(0) as StorageKeyComponent, components[i].substring(1));
+  }
+  return storageKey;
+}
+
+export const enum StorageKeyComponent {
+  TOP_LEVEL_SITE = '0',
+  NONCE_HIGH = '1',
+  NONCE_LOW = '2',
+  ANCESTOR_CHAIN_BIT = '3',
+  TOP_LEVEL_SITE_OPAQUE_NONCE_HIGH = '4',
+  TOP_LEVEL_SITE_OPAQUE_NONCE_LOW = '5',
+  TOP_LEVEL_SITE_OPAQUE_NONCE_PRECURSOR = '6',
+}
+
+export interface StorageKey {
+  origin: Platform.DevToolsPath.UrlString;
+  components: Map<StorageKeyComponent, string>;
+}
+
+export const enum Events {
+  STORAGE_KEY_ADDED = 'StorageKeyAdded',
+  STORAGE_KEY_REMOVED = 'StorageKeyRemoved',
+  MAIN_STORAGE_KEY_CHANGED = 'MainStorageKeyChanged',
+}
+
+export interface MainStorageKeyChangedEvent {
+  mainStorageKey: string;
+}
+
+export interface EventTypes {
+  [Events.STORAGE_KEY_ADDED]: string;
+  [Events.STORAGE_KEY_REMOVED]: string;
+  [Events.MAIN_STORAGE_KEY_CHANGED]: MainStorageKeyChangedEvent;
+}
+
+// TODO(jarhar): this is the one of the two usages of Capability.None. Do something about it!
+SDKModel.register(StorageKeyManager, {capabilities: Capability.NONE, autostart: false});

package/lib/front_end/core/sdk/Target.ts

@@ -0,0 +1,332 @@
+// 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.
+
+import type * as Protocol from '../../generated/protocol.js';
+import * as Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import * as ProtocolClient from '../protocol_client/protocol_client.js';
+
+import {SDKModel} from './SDKModel.js';
+import type {TargetManager} from './TargetManager.js';
+
+export class Target extends ProtocolClient.InspectorBackend.TargetBase {
+  readonly #targetManager: TargetManager;
+  #name: string;
+  #inspectedURL: Platform.DevToolsPath.UrlString = Platform.DevToolsPath.EmptyUrlString;
+  #inspectedURLName = '';
+  readonly #capabilitiesMask: number;
+  #type: Type;
+  readonly #parentTarget: Target|null;
+  #id: Protocol.Target.TargetID|'main';
+  #modelByConstructor = new Map<new(arg1: Target) => SDKModel, SDKModel>();
+  #isSuspended: boolean;
+  /**
+   * Generally when a target crashes we don't need to know, with one exception.
+   * If a target crashes during the recording of a performance trace, after the
+   * trace when we try to resume() it, it will fail because it has crashed. This
+   * causes the performance panel to freeze (see crbug.com/333989070). So we
+   * mark the target as crashed so we can exit without trying to resume it. In
+   * `ChildTargetManager` we will mark a target as "un-crashed" when we get the
+   * `targetInfoChanged` event. This helps ensure we can deal with cases where
+   * the page crashes, but a reload fixes it and the targets get restored (see
+   * crbug.com/387258086).
+   */
+  #hasCrashed = false;
+  #targetInfo: Protocol.Target.TargetInfo|undefined;
+  #creatingModels?: boolean;
+
+  constructor(
+      targetManager: TargetManager, id: Protocol.Target.TargetID|'main', name: string, type: Type,
+      parentTarget: Target|null, sessionId: string, suspended: boolean,
+      connection: ProtocolClient.ConnectionTransport.ConnectionTransport|null,
+      targetInfo?: Protocol.Target.TargetInfo) {
+    const needsNodeJSPatching = type === Type.NODE;
+    super(needsNodeJSPatching, parentTarget, sessionId, connection);
+    this.#targetManager = targetManager;
+    this.#name = name;
+    this.#capabilitiesMask = 0;
+    switch (type) {
+      case Type.FRAME:
+        this.#capabilitiesMask = Capability.BROWSER | Capability.STORAGE | Capability.DOM | Capability.JS |
+            Capability.LOG | Capability.NETWORK | Capability.TARGET | Capability.TRACING | Capability.EMULATION |
+            Capability.INPUT | Capability.INSPECTOR | Capability.AUDITS | Capability.WEB_AUTHN | Capability.IO |
+            Capability.MEDIA | Capability.EVENT_BREAKPOINTS;
+        if (parentTarget?.type() !== Type.FRAME) {
+          // This matches backend exposing certain capabilities only for the main frame.
+          this.#capabilitiesMask |=
+              Capability.DEVICE_EMULATION | Capability.SCREEN_CAPTURE | Capability.SECURITY | Capability.SERVICE_WORKER;
+          if (Common.ParsedURL.schemeIs(targetInfo?.url as Platform.DevToolsPath.UrlString, 'chrome-extension:')) {
+            this.#capabilitiesMask &= ~Capability.SECURITY;
+          }
+
+          // TODO(dgozman): we report service workers for the whole frame tree on the main frame,
+          // while we should be able to only cover the subtree corresponding to the target.
+        }
+        break;
+      case Type.ServiceWorker:
+        this.#capabilitiesMask = Capability.JS | Capability.LOG | Capability.NETWORK | Capability.TARGET |
+            Capability.INSPECTOR | Capability.IO | Capability.EVENT_BREAKPOINTS;
+        if (parentTarget?.type() !== Type.FRAME) {
+          this.#capabilitiesMask |= Capability.BROWSER | Capability.STORAGE;
+        }
+        break;
+      case Type.SHARED_WORKER:
+        this.#capabilitiesMask = Capability.JS | Capability.LOG | Capability.NETWORK | Capability.TARGET |
+            Capability.IO | Capability.MEDIA | Capability.INSPECTOR | Capability.EVENT_BREAKPOINTS;
+        if (parentTarget?.type() !== Type.FRAME) {
+          this.#capabilitiesMask |= Capability.STORAGE;
+        }
+        break;
+      case Type.SHARED_STORAGE_WORKLET:
+        this.#capabilitiesMask = Capability.JS | Capability.LOG | Capability.INSPECTOR | Capability.EVENT_BREAKPOINTS;
+        break;
+      case Type.Worker:
+        this.#capabilitiesMask = Capability.JS | Capability.LOG | Capability.NETWORK | Capability.TARGET |
+            Capability.IO | Capability.MEDIA | Capability.EMULATION | Capability.EVENT_BREAKPOINTS;
+        if (parentTarget?.type() !== Type.FRAME) {
+          this.#capabilitiesMask |= Capability.STORAGE;
+        }
+        break;
+      case Type.WORKLET:
+        this.#capabilitiesMask = Capability.JS | Capability.LOG | Capability.EVENT_BREAKPOINTS | Capability.NETWORK;
+        break;
+      case Type.NODE:
+        this.#capabilitiesMask = Capability.JS | Capability.NETWORK | Capability.TARGET | Capability.IO;
+        break;
+      case Type.AUCTION_WORKLET:
+        this.#capabilitiesMask = Capability.JS | Capability.EVENT_BREAKPOINTS;
+        break;
+      case Type.BROWSER:
+        this.#capabilitiesMask = Capability.TARGET | Capability.IO;
+        break;
+      case Type.TAB:
+        this.#capabilitiesMask = Capability.TARGET | Capability.TRACING;
+        break;
+      case Type.NODE_WORKER:
+        this.#capabilitiesMask = Capability.JS | Capability.NETWORK | Capability.TARGET | Capability.IO;
+    }
+    this.#type = type;
+    this.#parentTarget = parentTarget;
+    this.#id = id;
+    this.#isSuspended = suspended;
+    this.#targetInfo = targetInfo;
+  }
+
+  createModels(required: Set<new(arg1: Target) => SDKModel>): void {
+    this.#creatingModels = true;
+    const registeredModels = Array.from(SDKModel.registeredModels.entries());
+    // Create early models.
+    for (const [modelClass, info] of registeredModels) {
+      if (info.early) {
+        this.model(modelClass);
+      }
+    }
+    // Create autostart and required models.
+    for (const [modelClass, info] of registeredModels) {
+      if (info.autostart || required.has(modelClass)) {
+        this.model(modelClass);
+      }
+    }
+    this.#creatingModels = false;
+  }
+
+  id(): Protocol.Target.TargetID|'main' {
+    return this.#id;
+  }
+
+  name(): string {
+    return this.#name || this.#inspectedURLName;
+  }
+
+  setName(name: string): void {
+    if (this.#name === name) {
+      return;
+    }
+    this.#name = name;
+    this.#targetManager.onNameChange(this);
+  }
+
+  type(): Type {
+    return this.#type;
+  }
+
+  override markAsNodeJSForTest(): void {
+    super.markAsNodeJSForTest();
+    this.#type = Type.NODE;
+  }
+
+  targetManager(): TargetManager {
+    return this.#targetManager;
+  }
+
+  hasAllCapabilities(capabilitiesMask: number): boolean {
+    // TODO(dgozman): get rid of this method, once we never observe targets with
+    // capability mask.
+    return (this.#capabilitiesMask & capabilitiesMask) === capabilitiesMask;
+  }
+
+  decorateLabel(label: string): string {
+    return (this.#type === Type.Worker || this.#type === Type.ServiceWorker) ? '\u2699 ' + label : label;
+  }
+
+  parentTarget(): Target|null {
+    return this.#parentTarget;
+  }
+
+  outermostTarget(): Target|null {
+    let lastTarget: Target|null = null;
+    let currentTarget: Target|null = this;
+    do {
+      if (currentTarget.type() !== Type.TAB && currentTarget.type() !== Type.BROWSER) {
+        lastTarget = currentTarget;
+      }
+      currentTarget = currentTarget.parentTarget();
+    } while (currentTarget);
+
+    return lastTarget;
+  }
+
+  override dispose(reason: string): void {
+    super.dispose(reason);
+    this.#targetManager.removeTarget(this);
+    for (const model of this.#modelByConstructor.values()) {
+      model.dispose();
+    }
+  }
+
+  model<T extends SDKModel>(modelClass: new(arg1: Target) => T): T|null {
+    if (!this.#modelByConstructor.get(modelClass)) {
+      const info = SDKModel.registeredModels.get(modelClass);
+      if (info === undefined) {
+        throw new Error('Model class is not registered');
+      }
+      if ((this.#capabilitiesMask & info.capabilities) === info.capabilities) {
+        const model = new modelClass(this);
+        this.#modelByConstructor.set(modelClass, model);
+        if (!this.#creatingModels) {
+          this.#targetManager.modelAdded(modelClass, model, this.#targetManager.isInScope(this));
+        }
+      }
+    }
+    return (this.#modelByConstructor.get(modelClass) as T) || null;
+  }
+
+  models(): Map<new(arg1: Target) => SDKModel, SDKModel> {
+    return this.#modelByConstructor;
+  }
+
+  inspectedURL(): Platform.DevToolsPath.UrlString {
+    return this.#inspectedURL;
+  }
+
+  setInspectedURL(inspectedURL: Platform.DevToolsPath.UrlString): void {
+    this.#inspectedURL = inspectedURL;
+    const parsedURL = Common.ParsedURL.ParsedURL.fromString(inspectedURL);
+    this.#inspectedURLName = parsedURL ? parsedURL.lastPathComponentWithFragment() : '#' + this.#id;
+    this.#targetManager.onInspectedURLChange(this);
+    if (!this.#name) {
+      this.#targetManager.onNameChange(this);
+    }
+  }
+
+  hasCrashed(): boolean {
+    return this.#hasCrashed;
+  }
+
+  setHasCrashed(isCrashed: boolean): void {
+    const wasCrashed = this.#hasCrashed;
+
+    this.#hasCrashed = isCrashed;
+    // If the target has now been restored, check to see if it needs resuming.
+    // This ensures that if a target crashes whilst suspended, it is resumed
+    // when it is recovered.
+    // If the target is not suspended, resume() is a no-op, so it's safe to call.
+    if (wasCrashed && !isCrashed) {
+      void this.resume();
+    }
+  }
+
+  async suspend(reason?: string): Promise<void> {
+    if (this.#isSuspended) {
+      return;
+    }
+    this.#isSuspended = true;
+
+    // If the target has crashed, we will not attempt to suspend all the
+    // models, but we still mark it as suspended so we correctly track the
+    // state.
+    if (this.#hasCrashed) {
+      return;
+    }
+
+    await Promise.all(Array.from(this.models().values(), m => m.preSuspendModel(reason)));
+    await Promise.all(Array.from(this.models().values(), m => m.suspendModel(reason)));
+  }
+
+  async resume(): Promise<void> {
+    if (!this.#isSuspended) {
+      return;
+    }
+    this.#isSuspended = false;
+
+    if (this.#hasCrashed) {
+      return;
+    }
+
+    await Promise.all(Array.from(this.models().values(), m => m.resumeModel()));
+    await Promise.all(Array.from(this.models().values(), m => m.postResumeModel()));
+  }
+
+  suspended(): boolean {
+    return this.#isSuspended;
+  }
+
+  updateTargetInfo(targetInfo: Protocol.Target.TargetInfo): void {
+    this.#targetInfo = targetInfo;
+  }
+
+  targetInfo(): Protocol.Target.TargetInfo|undefined {
+    return this.#targetInfo;
+  }
+}
+
+export enum Type {
+  FRAME = 'frame',
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- Used by web_tests.
+  ServiceWorker = 'service-worker',
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- Used by web_tests.
+  Worker = 'worker',
+  SHARED_WORKER = 'shared-worker',
+  SHARED_STORAGE_WORKLET = 'shared-storage-worklet',
+  NODE = 'node',
+  BROWSER = 'browser',
+  AUCTION_WORKLET = 'auction-worklet',
+  WORKLET = 'worklet',
+  TAB = 'tab',
+  NODE_WORKER = 'node-worker',
+}
+
+export const enum Capability {
+  BROWSER = 1 << 0,
+  DOM = 1 << 1,
+  JS = 1 << 2,
+  LOG = 1 << 3,
+  NETWORK = 1 << 4,
+  TARGET = 1 << 5,
+  SCREEN_CAPTURE = 1 << 6,
+  TRACING = 1 << 7,
+  EMULATION = 1 << 8,
+  SECURITY = 1 << 9,
+  INPUT = 1 << 10,
+  INSPECTOR = 1 << 11,
+  DEVICE_EMULATION = 1 << 12,
+  STORAGE = 1 << 13,
+  SERVICE_WORKER = 1 << 14,
+  AUDITS = 1 << 15,
+  WEB_AUTHN = 1 << 16,
+  IO = 1 << 17,
+  MEDIA = 1 << 18,
+  EVENT_BREAKPOINTS = 1 << 19,
+  NONE = 0,
+}