devtools-tracing 1.0.0

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

@@ -0,0 +1,184 @@
+// 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 * as Common from '../../core/common/common.js';
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import * as Host from '../host/host.js';
+
+import {SDKModel} from './SDKModel.js';
+import {Capability, type Target} from './Target.js';
+
+export class AutofillModel extends SDKModel<EventTypes> implements ProtocolProxyApi.AutofillDispatcher {
+  readonly agent: ProtocolProxyApi.AutofillApi;
+  #enabled?: boolean;
+  #showTestAddressesInAutofillMenu: Common.Settings.Setting<boolean>;
+
+  constructor(target: Target) {
+    super(target);
+
+    this.agent = target.autofillAgent();
+    this.#showTestAddressesInAutofillMenu =
+        Common.Settings.Settings.instance().createSetting('show-test-addresses-in-autofill-menu-on-event', false);
+    this.#showTestAddressesInAutofillMenu.addChangeListener(this.#setTestAddresses, this);
+    target.registerAutofillDispatcher(this);
+    this.enable();
+  }
+
+  override dispose(): void {
+    this.#showTestAddressesInAutofillMenu.removeChangeListener(this.#setTestAddresses, this);
+    super.dispose();
+  }
+
+  #setTestAddresses(): void {
+    void this.agent.invoke_setAddresses(
+        {
+          addresses: this.#showTestAddressesInAutofillMenu.get() ?
+              [
+                {
+                  fields: [
+                    {name: 'ADDRESS_HOME_COUNTRY', value: 'US'},
+                    {name: 'NAME_FULL', value: 'Jon Stewart Doe'},
+                    {name: 'NAME_FIRST', value: 'Jon'},
+                    {name: 'NAME_MIDDLE', value: 'Stewart'},
+                    {name: 'NAME_LAST', value: 'Doe'},
+                    {name: 'COMPANY_NAME', value: 'Fake Company'},
+                    {name: 'ADDRESS_HOME_LINE1', value: '1600 Fake Street'},
+                    {name: 'ADDRESS_HOME_LINE2', value: 'Apartment 1'},
+                    {name: 'ADDRESS_HOME_ZIP', value: '94043'},
+                    {name: 'ADDRESS_HOME_CITY', value: 'Mountain View'},
+                    {name: 'ADDRESS_HOME_STATE', value: 'CA'},
+                    {name: 'EMAIL_ADDRESS', value: 'test@example.us'},
+                    {name: 'PHONE_HOME_WHOLE_NUMBER', value: '+16019521325'},
+                  ],
+                },
+                {
+                  fields: [
+                    {name: 'ADDRESS_HOME_COUNTRY', value: 'BR'},
+                    {name: 'NAME_FULL', value: 'João Souza Silva'},
+                    {name: 'NAME_FIRST', value: 'João'},
+                    {name: 'NAME_LAST', value: 'Souza Silva'},
+                    {name: 'NAME_LAST_FIRST', value: 'Souza'},
+                    {name: 'NAME_LAST_SECOND', value: 'Silva'},
+                    {name: 'COMPANY_NAME', value: 'Empresa Falsa'},
+                    {name: 'ADDRESS_HOME_STREET_ADDRESS', value: 'Rua Inexistente, 2000\nAndar 2, Apartamento 1'},
+                    {name: 'ADDRESS_HOME_STREET_LOCATION', value: 'Rua Inexistente, 2000'},
+                    {name: 'ADDRESS_HOME_STREET_NAME', value: 'Rua Inexistente'},
+                    {name: 'ADDRESS_HOME_HOUSE_NUMBER', value: '2000'},
+                    {name: 'ADDRESS_HOME_SUBPREMISE', value: 'Andar 2, Apartamento 1'},
+                    {name: 'ADDRESS_HOME_APT_NUM', value: '1'},
+                    {name: 'ADDRESS_HOME_FLOOR', value: '2'},
+                    {name: 'ADDRESS_HOME_APT', value: 'Apartamento 1'},
+                    {name: 'ADDRESS_HOME_APT_TYPE', value: 'Apartamento'},
+                    {name: 'ADDRESS_HOME_APT_NUM', value: '1'},
+                    {name: 'ADDRESS_HOME_DEPENDENT_LOCALITY', value: 'Santa Efigênia'},
+                    {name: 'ADDRESS_HOME_LANDMARK', value: 'Próximo à estação Santa Efigênia'},
+                    {name: 'ADDRESS_HOME_OVERFLOW', value: 'Andar 2, Apartamento 1'},
+                    {name: 'ADDRESS_HOME_ZIP', value: '30260-080'},
+                    {name: 'ADDRESS_HOME_CITY', value: 'Belo Horizonte'},
+                    {name: 'ADDRESS_HOME_STATE', value: 'MG'},
+                    {name: 'EMAIL_ADDRESS', value: 'teste@exemplo.us'},
+                    {name: 'PHONE_HOME_WHOLE_NUMBER', value: '+553121286800'},
+                  ],
+                },
+                {
+                  fields: [
+                    {name: 'ADDRESS_HOME_COUNTRY', value: 'MX'},
+                    {name: 'NAME_FULL', value: 'Juan Francisco García Flores'},
+                    {name: 'NAME_FIRST', value: 'Juan Francisco'},
+                    {name: 'NAME_LAST', value: 'García Flores'},
+                    {name: 'NAME_LAST_FIRST', value: 'García'},
+                    {name: 'NAME_LAST_SECOND', value: 'Flores'},
+                    {name: 'COMPANY_NAME', value: 'Empresa Falsa'},
+                    {
+                      name: 'ADDRESS_HOME_STREET_ADDRESS',
+                      value:
+                          'C. Falsa 445\nPiso 2, Apartamento 1\nEntre calle Volcán y calle Montes Blancos, cerca de la estación de metro',
+                    },
+                    {name: 'ADDRESS_HOME_STREET_LOCATION', value: 'C. Falsa 445'},
+                    {name: 'ADDRESS_HOME_STREET_NAME', value: 'C. Falsa'},
+                    {name: 'ADDRESS_HOME_HOUSE_NUMBER', value: '445'},
+                    {name: 'ADDRESS_HOME_SUBPREMISE', value: 'Piso 2, Apartamento 1'},
+                    {name: 'ADDRESS_HOME_FLOOR', value: '2'},
+                    {name: 'ADDRESS_HOME_APT', value: 'Apartamento 1'},
+                    {name: 'ADDRESS_HOME_APT_TYPE', value: 'Apartamento'},
+                    {name: 'ADDRESS_HOME_APT_NUM', value: '1'},
+                    {name: 'ADDRESS_HOME_DEPENDENT_LOCALITY', value: 'Lomas de Chapultepec'},
+                    {
+                      name: 'ADDRESS_HOME_OVERFLOW',
+                      value: 'Entre calle Volcán y calle Montes Celestes, cerca de la estación de metro',
+                    },
+                    {
+                      name: 'ADDRESS_HOME_BETWEEN_STREETS_OR_LANDMARK',
+                      value: 'Entre calle Volcán y calle Montes Blancos, cerca de la estación de metro',
+                    },
+                    {name: 'ADDRESS_HOME_LANDMARK', value: 'Cerca de la estación de metro'},
+                    {name: 'ADDRESS_HOME_BETWEEN_STREETS', value: 'Entre calle Volcán y calle Montes Blancos'},
+                    {name: 'ADDRESS_HOME_BETWEEN_STREETS_1', value: 'calle Volcán'},
+                    {name: 'ADDRESS_HOME_BETWEEN_STREETS_2', value: 'calle Montes Blancos'},
+                    {name: 'ADDRESS_HOME_ADMIN_LEVEL2', value: 'Miguel Hidalgo'},
+                    {name: 'ADDRESS_HOME_ZIP', value: '11001'},
+                    {name: 'ADDRESS_HOME_CITY', value: 'Ciudad de México'},
+                    {name: 'ADDRESS_HOME_STATE', value: 'Distrito Federal'},
+                    {name: 'EMAIL_ADDRESS', value: 'ejemplo@ejemplo.mx'},
+                    {name: 'PHONE_HOME_WHOLE_NUMBER', value: '+525553428400'},
+                  ],
+                },
+                {
+                  fields: [
+                    {name: 'ADDRESS_HOME_COUNTRY', value: 'DE'},
+                    {name: 'NAME_FULL', value: 'Gottfried Wilhelm Leibniz'},
+                    {name: 'NAME_FIRST', value: 'Gottfried'},
+                    {name: 'NAME_MIDDLE', value: 'Wilhelm'},
+                    {name: 'NAME_LAST', value: 'Leibniz'},
+                    {name: 'COMPANY_NAME', value: 'Erfundenes Unternehmen'},
+                    {name: 'ADDRESS_HOME_LINE1', value: 'Erfundene Straße 33'},
+                    {name: 'ADDRESS_HOME_LINE2', value: 'Wohnung 1'},
+                    {name: 'ADDRESS_HOME_ZIP', value: '80732'},
+                    {name: 'ADDRESS_HOME_CITY', value: 'München'},
+                    {name: 'EMAIL_ADDRESS', value: 'test@beispiel.de'},
+                    {name: 'PHONE_HOME_WHOLE_NUMBER', value: '+4930303986300'},
+                  ],
+                },
+              ] :
+              [],
+        });
+  }
+
+  enable(): void {
+    if (this.#enabled || Host.InspectorFrontendHost.isUnderTest()) {
+      return;
+    }
+    void this.agent.invoke_enable();
+    this.#setTestAddresses();
+    this.#enabled = true;
+  }
+
+  disable(): void {
+    if (!this.#enabled || Host.InspectorFrontendHost.isUnderTest()) {
+      return;
+    }
+    this.#enabled = false;
+    void this.agent.invoke_disable();
+  }
+
+  addressFormFilled(addressFormFilledEvent: Protocol.Autofill.AddressFormFilledEvent): void {
+    this.dispatchEventToListeners(Events.ADDRESS_FORM_FILLED, {autofillModel: this, event: addressFormFilledEvent});
+  }
+}
+
+SDKModel.register(AutofillModel, {capabilities: Capability.DOM, autostart: true});
+
+export const enum Events {
+  ADDRESS_FORM_FILLED = 'AddressFormFilled',
+}
+
+export interface AddressFormFilledEvent {
+  autofillModel: AutofillModel;
+  event: Protocol.Autofill.AddressFormFilledEvent;
+}
+
+export interface EventTypes {
+  [Events.ADDRESS_FORM_FILLED]: AddressFormFilledEvent;
+}

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

@@ -0,0 +1,148 @@
+// 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 ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import * as i18n from '../i18n/i18n.js';
+
+import {DebuggerModel, Location} from './DebuggerModel.js';
+import type {RuntimeModel} from './RuntimeModel.js';
+import {SDKModel} from './SDKModel.js';
+import {Capability, type Target} from './Target.js';
+
+const UIStrings = {
+  /**
+   * @description Name of a profile. Placeholder is either a user-supplied name or a number automatically assigned to the profile.
+   * @example {2} PH1
+   */
+  profileD: 'Profile {PH1}',
+} as const;
+const str_ = i18n.i18n.registerUIStrings('core/sdk/CPUProfilerModel.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+
+export class CPUProfilerModel extends SDKModel<EventTypes> implements ProtocolProxyApi.ProfilerDispatcher {
+  #nextAnonymousConsoleProfileNumber: number;
+  #anonymousConsoleProfileIdToTitle: Map<string, string>;
+  readonly #profilerAgent: ProtocolProxyApi.ProfilerApi;
+  #preciseCoverageDeltaUpdateCallback: ((arg0: number, arg2: Protocol.Profiler.ScriptCoverage[]) => Promise<void>)|null;
+  readonly #debuggerModel: DebuggerModel;
+  readonly registeredConsoleProfileMessages: ProfileFinishedData[] = [];
+
+  constructor(target: Target) {
+    super(target);
+    this.#nextAnonymousConsoleProfileNumber = 1;
+    this.#anonymousConsoleProfileIdToTitle = new Map();
+    this.#profilerAgent = target.profilerAgent();
+    this.#preciseCoverageDeltaUpdateCallback = null;
+    target.registerProfilerDispatcher(this);
+    void this.#profilerAgent.invoke_enable();
+    this.#debuggerModel = (target.model(DebuggerModel) as DebuggerModel);
+  }
+
+  runtimeModel(): RuntimeModel {
+    return this.#debuggerModel.runtimeModel();
+  }
+
+  debuggerModel(): DebuggerModel {
+    return this.#debuggerModel;
+  }
+
+  consoleProfileStarted({id, location, title}: Protocol.Profiler.ConsoleProfileStartedEvent): void {
+    if (!title) {
+      title = i18nString(UIStrings.profileD, {PH1: this.#nextAnonymousConsoleProfileNumber++});
+      this.#anonymousConsoleProfileIdToTitle.set(id, title);
+    }
+    const eventData = this.createEventDataFrom(id, location, title);
+    this.dispatchEventToListeners(Events.CONSOLE_PROFILE_STARTED, eventData);
+  }
+
+  consoleProfileFinished({id, location, profile, title}: Protocol.Profiler.ConsoleProfileFinishedEvent): void {
+    if (!title) {
+      title = this.#anonymousConsoleProfileIdToTitle.get(id);
+      this.#anonymousConsoleProfileIdToTitle.delete(id);
+    }
+    const eventData: ProfileFinishedData = {
+      ...this.createEventDataFrom(id, location, title),
+      cpuProfile: profile,
+    };
+    this.registeredConsoleProfileMessages.push(eventData);
+    this.dispatchEventToListeners(Events.CONSOLE_PROFILE_FINISHED, eventData);
+  }
+
+  private createEventDataFrom(id: string, scriptLocation: Protocol.Debugger.Location, title?: string): EventData {
+    const debuggerLocation = Location.fromPayload(this.#debuggerModel, scriptLocation);
+    const globalId = this.target().id() + '.' + id;
+    return {
+      id: globalId,
+      scriptLocation: debuggerLocation,
+      title: title || '',
+      cpuProfilerModel: this,
+    };
+  }
+
+  startRecording(): Promise<unknown> {
+    const intervalUs = 100;
+    void this.#profilerAgent.invoke_setSamplingInterval({interval: intervalUs});
+    return this.#profilerAgent.invoke_start();
+  }
+
+  stopRecording(): Promise<Protocol.Profiler.Profile|null> {
+    return this.#profilerAgent.invoke_stop().then(response => response.profile || null);
+  }
+
+  startPreciseCoverage(
+      jsCoveragePerBlock: boolean,
+      preciseCoverageDeltaUpdateCallback: ((arg0: number, arg2: Protocol.Profiler.ScriptCoverage[]) => Promise<void>)|
+      null): Promise<unknown> {
+    const callCount = false;
+    this.#preciseCoverageDeltaUpdateCallback = preciseCoverageDeltaUpdateCallback;
+    const allowUpdatesTriggeredByBackend = true;
+    return this.#profilerAgent.invoke_startPreciseCoverage(
+        {callCount, detailed: jsCoveragePerBlock, allowTriggeredUpdates: allowUpdatesTriggeredByBackend});
+  }
+
+  async takePreciseCoverage(): Promise<{
+    timestamp: number,
+    coverage: Protocol.Profiler.ScriptCoverage[],
+  }> {
+    const r = await this.#profilerAgent.invoke_takePreciseCoverage();
+    const timestamp = (r?.timestamp) || 0;
+    const coverage = (r?.result) || [];
+    return {timestamp, coverage};
+  }
+
+  stopPreciseCoverage(): Promise<unknown> {
+    this.#preciseCoverageDeltaUpdateCallback = null;
+    return this.#profilerAgent.invoke_stopPreciseCoverage();
+  }
+
+  preciseCoverageDeltaUpdate({timestamp, result}: Protocol.Profiler.PreciseCoverageDeltaUpdateEvent): void {
+    if (this.#preciseCoverageDeltaUpdateCallback) {
+      void this.#preciseCoverageDeltaUpdateCallback(timestamp, result);
+    }
+  }
+}
+
+export const enum Events {
+  CONSOLE_PROFILE_STARTED = 'ConsoleProfileStarted',
+  CONSOLE_PROFILE_FINISHED = 'ConsoleProfileFinished',
+}
+
+export interface EventTypes {
+  [Events.CONSOLE_PROFILE_STARTED]: EventData;
+  [Events.CONSOLE_PROFILE_FINISHED]: ProfileFinishedData;
+}
+
+SDKModel.register(CPUProfilerModel, {capabilities: Capability.JS, autostart: true});
+
+export interface EventData {
+  id: string;
+  scriptLocation: Location;
+  title: string;
+  cpuProfilerModel: CPUProfilerModel;
+}
+
+export interface ProfileFinishedData extends EventData {
+  cpuProfile: Protocol.Profiler.Profile;
+}

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

@@ -0,0 +1,282 @@
+// Copyright 2017 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 i18n from '../i18n/i18n.js';
+
+import {EmulationModel} from './EmulationModel.js';
+import {type SDKModelObserver, TargetManager} from './TargetManager.js';
+
+const UIStrings = {
+  /**
+   * @description Text label for a menu item indicating that no throttling is applied.
+   */
+  noThrottling: 'No throttling',
+  /**
+   * @description Text label for a menu item indicating that a specific slowdown multiplier is applied.
+   * @example {2} PH1
+   */
+  dSlowdown: '{PH1}× slowdown',
+  /**
+   * @description Text label for a menu item indicating an average mobile device.
+   */
+  calibratedMidTierMobile: 'Mid-tier mobile',
+  /**
+   * @description Text label for a menu item indicating a below-average mobile device.
+   */
+  calibratedLowTierMobile: 'Low-tier mobile',
+  /**
+   * @description Text label indicating why an option is not available, because the user's device is not fast enough to emulate a device.
+   */
+  calibrationErrorDeviceTooWeak: 'Device is not powerful enough',
+} as const;
+const str_ = i18n.i18n.registerUIStrings('core/sdk/CPUThrottlingManager.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+
+let throttlingManagerInstance: CPUThrottlingManager;
+
+export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
+    SDKModelObserver<EmulationModel> {
+  #cpuThrottlingOption: CPUThrottlingOption;
+  #calibratedThrottlingSetting: Common.Settings.Setting<CalibratedCPUThrottling>;
+  #hardwareConcurrency?: number;
+  #pendingMainTargetPromise?: (r: number) => void;
+
+  private constructor() {
+    super();
+    this.#cpuThrottlingOption = NoThrottlingOption;
+    this.#calibratedThrottlingSetting = Common.Settings.Settings.instance().createSetting<CalibratedCPUThrottling>(
+        'calibrated-cpu-throttling', {}, Common.Settings.SettingStorageType.GLOBAL);
+    this.#calibratedThrottlingSetting.addChangeListener(this.#onCalibratedSettingChanged, this);
+    TargetManager.instance().observeModels(EmulationModel, this);
+  }
+
+  static instance(opts: {forceNew: boolean|null} = {forceNew: null}): CPUThrottlingManager {
+    const {forceNew} = opts;
+    if (!throttlingManagerInstance || forceNew) {
+      throttlingManagerInstance = new CPUThrottlingManager();
+    }
+
+    return throttlingManagerInstance;
+  }
+
+  cpuThrottlingRate(): number {
+    return this.#cpuThrottlingOption.rate();
+  }
+
+  cpuThrottlingOption(): CPUThrottlingOption {
+    return this.#cpuThrottlingOption;
+  }
+
+  #onCalibratedSettingChanged(): void {
+    // If a calibrated option is selected, need to propagate new rate.
+    const currentOption = this.#cpuThrottlingOption;
+    if (!currentOption.calibratedDeviceType) {
+      return;
+    }
+
+    const rate = this.#cpuThrottlingOption.rate();
+    if (rate === 0) {
+      // This calibrated option is no longer valid.
+      this.setCPUThrottlingOption(NoThrottlingOption);
+      return;
+    }
+
+    for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+      void emulationModel.setCPUThrottlingRate(rate);
+    }
+    this.dispatchEventToListeners(Events.RATE_CHANGED, rate);
+  }
+
+  setCPUThrottlingOption(option: CPUThrottlingOption): void {
+    if (option === this.#cpuThrottlingOption) {
+      return;
+    }
+
+    this.#cpuThrottlingOption = option;
+    for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+      void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingOption.rate());
+    }
+    this.dispatchEventToListeners(Events.RATE_CHANGED, this.#cpuThrottlingOption.rate());
+  }
+
+  setHardwareConcurrency(concurrency: number): void {
+    this.#hardwareConcurrency = concurrency;
+    for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+      void emulationModel.setHardwareConcurrency(concurrency);
+    }
+    this.dispatchEventToListeners(Events.HARDWARE_CONCURRENCY_CHANGED, this.#hardwareConcurrency);
+  }
+
+  hasPrimaryPageTargetSet(): boolean {
+    // In some environments, such as Node, trying to check if we have a page
+    // target may error. So if we get any errors here at all, assume that we do
+    // not have a target.
+    try {
+      return TargetManager.instance().primaryPageTarget() !== null;
+    } catch {
+      return false;
+    }
+  }
+
+  async getHardwareConcurrency(): Promise<number> {
+    const target = TargetManager.instance().primaryPageTarget();
+    const existingCallback = this.#pendingMainTargetPromise;
+
+    // If the main target hasn't attached yet, block callers until it appears.
+    if (!target) {
+      if (existingCallback) {
+        return await new Promise(r => {
+          this.#pendingMainTargetPromise = (result: number) => {
+            r(result);
+            existingCallback(result);
+          };
+        });
+      }
+      return await new Promise(r => {
+        this.#pendingMainTargetPromise = r;
+      });
+    }
+
+    const evalResult = await target.runtimeAgent().invoke_evaluate(
+        {expression: 'navigator.hardwareConcurrency', returnByValue: true, silent: true, throwOnSideEffect: true});
+    const error = evalResult.getError();
+    if (error) {
+      throw new Error(error);
+    }
+    const {result, exceptionDetails} = evalResult;
+    if (exceptionDetails) {
+      throw new Error(exceptionDetails.text);
+    }
+    return result.value;
+  }
+
+  modelAdded(emulationModel: EmulationModel): void {
+    if (this.#cpuThrottlingOption !== NoThrottlingOption) {
+      void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingOption.rate());
+    }
+    if (this.#hardwareConcurrency !== undefined) {
+      void emulationModel.setHardwareConcurrency(this.#hardwareConcurrency);
+    }
+
+    // If there are any callers blocked on a getHardwareConcurrency call, let's wake them now.
+    if (this.#pendingMainTargetPromise) {
+      const existingCallback = this.#pendingMainTargetPromise;
+      this.#pendingMainTargetPromise = undefined;
+      void this.getHardwareConcurrency().then(existingCallback);
+    }
+  }
+
+  modelRemoved(_emulationModel: EmulationModel): void {
+    // Implemented as a requirement for being a SDKModelObserver.
+  }
+}
+
+export const enum Events {
+  RATE_CHANGED = 'RateChanged',
+  HARDWARE_CONCURRENCY_CHANGED = 'HardwareConcurrencyChanged',
+}
+
+export interface EventTypes {
+  [Events.RATE_CHANGED]: number;
+  [Events.HARDWARE_CONCURRENCY_CHANGED]: number;
+}
+
+export function throttlingManager(): CPUThrottlingManager {
+  return CPUThrottlingManager.instance();
+}
+
+export enum CPUThrottlingRates {
+  NO_THROTTLING = 1,
+  MID_TIER_MOBILE = 4,
+  LOW_TIER_MOBILE = 6,
+  EXTRA_SLOW = 20,
+
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- Used by web_tests.
+  MidTierMobile = MID_TIER_MOBILE,
+  // eslint-disable-next-line @typescript-eslint/naming-convention -- Used by web_tests.
+  LowEndMobile = LOW_TIER_MOBILE,
+}
+
+export type CalibratedDeviceType = 'low-tier-mobile'|'mid-tier-mobile';
+
+export interface CPUThrottlingOption {
+  title: () => string;
+  rate: () => number;
+  calibratedDeviceType?: CalibratedDeviceType;
+  jslogContext: string;
+}
+
+function makeFixedPresetThrottlingOption(rate: CPUThrottlingRates): CPUThrottlingOption {
+  return {
+    title: rate === 1 ? i18nLazyString(UIStrings.noThrottling) : i18nLazyString(UIStrings.dSlowdown, {PH1: rate}),
+    rate: () => rate,
+    jslogContext: rate === 1 ? 'cpu-no-throttling' : `cpu-throttled-${rate}`,
+  };
+}
+
+export const NoThrottlingOption = makeFixedPresetThrottlingOption(CPUThrottlingRates.NO_THROTTLING);
+export const MidTierThrottlingOption = makeFixedPresetThrottlingOption(CPUThrottlingRates.MID_TIER_MOBILE);
+export const LowTierThrottlingOption = makeFixedPresetThrottlingOption(CPUThrottlingRates.LOW_TIER_MOBILE);
+export const ExtraSlowThrottlingOption = makeFixedPresetThrottlingOption(CPUThrottlingRates.EXTRA_SLOW);
+
+function makeCalibratedThrottlingOption(calibratedDeviceType: CalibratedDeviceType): CPUThrottlingOption {
+  const getSettingValue = (): number|CalibrationError|null => {
+    const setting = Common.Settings.Settings.instance().createSetting<CalibratedCPUThrottling>(
+        'calibrated-cpu-throttling', {}, Common.Settings.SettingStorageType.GLOBAL);
+    const value = setting.get();
+    if (calibratedDeviceType === 'low-tier-mobile') {
+      return value.low ?? null;
+    }
+    if (calibratedDeviceType === 'mid-tier-mobile') {
+      return value.mid ?? null;
+    }
+    return null;
+  };
+
+  return {
+    title(): string {
+      const typeString = calibratedDeviceType === 'low-tier-mobile' ? i18nString(UIStrings.calibratedLowTierMobile) :
+                                                                      i18nString(UIStrings.calibratedMidTierMobile);
+
+      const value = getSettingValue();
+      if (typeof value === 'number') {
+        return `${typeString} – ${value.toFixed(1)}×`;
+      }
+
+      return typeString;
+    },
+    rate(): number {
+      const value = getSettingValue();
+      if (typeof value === 'number') {
+        return value;
+      }
+      return 0;
+    },
+    calibratedDeviceType,
+    jslogContext: `cpu-throttled-calibrated-${calibratedDeviceType}`,
+  };
+}
+
+export const CalibratedLowTierMobileThrottlingOption = makeCalibratedThrottlingOption('low-tier-mobile');
+export const CalibratedMidTierMobileThrottlingOption = makeCalibratedThrottlingOption('mid-tier-mobile');
+
+export interface CalibratedCPUThrottling {
+  /** Either the CPU multiplier, or an error code for why it could not be determined. */
+  low?: number|CalibrationError;
+  mid?: number|CalibrationError;
+}
+
+export enum CalibrationError {
+  DEVICE_TOO_WEAK = 'DEVICE_TOO_WEAK',
+}
+
+export function calibrationErrorToString(error: CalibrationError): string {
+  if (error === CalibrationError.DEVICE_TOO_WEAK) {
+    return i18nString(UIStrings.calibrationErrorDeviceTooWeak);
+  }
+
+  return error;
+}