chrome-devtools-frontend 1.0.1684555 → 1.0.1689415

package/front_end/core/sdk/CPUThrottlingManager.ts

@@ -3,26 +3,80 @@
 // found in the LICENSE file.
 
 import * as Common from '../../core/common/common.js';
+import * as Protocol from '../../generated/protocol.js';
 import * as Root from '../root/root.js';
 
 import {EmulationModel} from './EmulationModel.js';
+import {cpuPerformanceSettingDescriptor} from './SDKSettings.js';
 import {type SDKModelObserver, TargetManager} from './TargetManager.js';
 
+export enum CalibrationError {
+  DEVICE_TOO_WEAK = 'DEVICE_TOO_WEAK',
+}
+
+export interface CalibratedCPUThrottling {
+  low?: number|CalibrationError;
+  mid?: number|CalibrationError;
+  actualScore?: number;
+}
+
+export import CPUPerformanceTier = Protocol.Emulation.SetCPUPerformanceOverrideRequestPerformanceTier;
+
+export function numberToTier(value: number): CPUPerformanceTier {
+  switch (value) {
+    case 1:
+      return CPUPerformanceTier.Low;
+    case 2:
+      return CPUPerformanceTier.Mid;
+    case 3:
+      return CPUPerformanceTier.High;
+    case 4:
+      return CPUPerformanceTier.Ultra;
+    default:
+      // This defaults to UNKNOWN (0) if the value is out of range.
+      return CPUPerformanceTier.Unknown;
+  }
+}
+
+export function tierToNumber(tier: CPUPerformanceTier): number {
+  switch (tier) {
+    case CPUPerformanceTier.Unknown:
+      return 0;
+    case CPUPerformanceTier.Low:
+      return 1;
+    case CPUPerformanceTier.Mid:
+      return 2;
+    case CPUPerformanceTier.High:
+      return 3;
+    case CPUPerformanceTier.Ultra:
+      return 4;
+  }
+}
+
 export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDKModelObserver<EmulationModel> {
+  readonly #calibratedCpuThrottlingSetting: Common.Settings.Setting<CalibratedCPUThrottling>;
+  readonly #cpuPerformanceSetting: Common.Settings.Setting<string>;
   readonly #targetManager: TargetManager;
   #cpuThrottlingRate: number;
   #hardwareConcurrency?: number;
+  #hostDefaultCPUPerformanceTier?: CPUPerformanceTier;
+  #manualCPUPerformanceOverride?: CPUPerformanceTier;
   #pendingMainTargetPromise?: (r: number) => void;
 
   constructor(settings: Common.Settings.Settings, targetManager: TargetManager) {
     super();
     this.#targetManager = targetManager;
     this.#cpuThrottlingRate = 1;  // No throttling
+    this.#calibratedCpuThrottlingSetting = settings.createSetting<CalibratedCPUThrottling>(
+        'calibrated-cpu-throttling', {}, Common.Settings.SettingStorageType.GLOBAL);
+    this.#cpuPerformanceSetting = settings.resolve(cpuPerformanceSettingDescriptor);
   }
 
   initialize(): void {
     this.#targetManager.observeModels(EmulationModel, this);
+    this.#cpuPerformanceSetting.addChangeListener(this.#onCPUPerformanceSettingChanged, this);
+    this.#onCPUPerformanceSettingChanged();
   }
 
   static instance(opts: {
@@ -51,6 +105,107 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
     return this.#cpuThrottlingRate;
   }
 
+  calculatedCPUPerformanceTier(): CPUPerformanceTier|undefined {
+    // Return the calculated tier, based on the host hardware baseline and any active CPU throttling multiplier,
+    // ignoring any manual override via the sensors panel.
+    // https://docs.google.com/document/d/1cVUQxigT9GMJweyR4c5Gmj16DEE7GnMTWy-FFPMkl14
+    const NOMINAL_SCORES = {
+      LOW: 264,
+      MID: 1000,
+      HIGH: 2350,
+      ULTRA: 3000,
+    };
+
+    const calibratedSetting = this.#calibratedCpuThrottlingSetting.get();
+    const isCalibrated = typeof calibratedSetting.actualScore === 'number' && calibratedSetting.actualScore > 0;
+
+    let rLow: number;
+    let rMid: number;
+    let rHigh: number;
+    let rUltra: number;
+
+    if (isCalibrated) {
+      const sHost = calibratedSetting.actualScore as number;
+      rLow = typeof calibratedSetting.low === 'number' ? calibratedSetting.low : 1.0;
+      rMid = typeof calibratedSetting.mid === 'number' ? calibratedSetting.mid : 1.0;
+      rHigh = Math.min(rMid, Math.max(sHost / NOMINAL_SCORES.HIGH, 1.0));
+      rUltra = Math.min(rHigh, Math.max(sHost / NOMINAL_SCORES.ULTRA, 1.0));
+    } else {
+      // If the host default tier is undefined or unknown, return that.
+      const hostTier = this.#hostDefaultCPUPerformanceTier;
+      if (!hostTier || hostTier === CPUPerformanceTier.Unknown) {
+        return hostTier;
+      }
+
+      let sHost;
+      switch (hostTier) {
+        case CPUPerformanceTier.Low:
+          sHost = NOMINAL_SCORES.LOW;
+          break;
+        case CPUPerformanceTier.Mid:
+          sHost = NOMINAL_SCORES.MID;
+          break;
+        case CPUPerformanceTier.High:
+          sHost = NOMINAL_SCORES.HIGH;
+          break;
+        default:
+          sHost = NOMINAL_SCORES.ULTRA;
+          break;
+      }
+      rLow = Math.max(sHost / NOMINAL_SCORES.LOW, 1.0);
+      rMid = Math.max(sHost / NOMINAL_SCORES.MID, 1.0);
+      rHigh = Math.max(sHost / NOMINAL_SCORES.HIGH, 1.0);
+      rUltra = Math.max(sHost / NOMINAL_SCORES.ULTRA, 1.0);
+    }
+
+    const thetaLow = Math.sqrt(rLow * rMid);
+    const thetaMid = Math.sqrt(rMid * rHigh);
+    const thetaHigh = Math.sqrt(rHigh * rUltra);
+
+    if (this.#cpuThrottlingRate >= thetaLow) {
+      return CPUPerformanceTier.Low;
+    }
+    if (this.#cpuThrottlingRate >= thetaMid) {
+      return CPUPerformanceTier.Mid;
+    }
+    if (this.#cpuThrottlingRate >= thetaHigh) {
+      return CPUPerformanceTier.High;
+    }
+    return CPUPerformanceTier.Ultra;
+  }
+
+  effectiveCPUPerformanceTier(): CPUPerformanceTier|undefined {
+    // Return the tier, applying the manual override, if any.
+    if (this.#manualCPUPerformanceOverride !== undefined) {
+      return this.#manualCPUPerformanceOverride;
+    }
+    return this.calculatedCPUPerformanceTier();
+  }
+
+  #onCPUPerformanceSettingChanged(): void {
+    const val = this.#cpuPerformanceSetting.get();
+    this.#manualCPUPerformanceOverride = val === 'no-override' ? undefined : val as CPUPerformanceTier;
+    this.#syncCPUPerformanceTier();
+    if (this.#hostDefaultCPUPerformanceTier === undefined) {
+      void this.updateHostDefaultCPUPerformanceTier();
+    }
+  }
+
+  #isCPUPerformanceOverrideActive(): boolean {
+    return this.#manualCPUPerformanceOverride !== undefined || this.#cpuThrottlingRate !== 1;
+  }
+
+  #syncCPUPerformanceTier(): void {
+    const effectiveTier = this.effectiveCPUPerformanceTier();
+    // Synchronize with Chromium backend, via CDP.
+    const activeOverride = this.#isCPUPerformanceOverrideActive() ? effectiveTier : undefined;
+    for (const emulationModel of this.#targetManager.models(EmulationModel)) {
+      void emulationModel.setCPUPerformanceOverride(activeOverride);
+    }
+    // Notify UI and other listeners.
+    this.dispatchEventToListeners(Events.CPU_PERFORMANCE_TIER_CHANGED, effectiveTier);
+  }
+
   setCPUThrottlingRate(rate: number): void {
     if (rate === this.#cpuThrottlingRate) {
       return;
@@ -61,6 +216,14 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
       void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingRate);
     }
     this.dispatchEventToListeners(Events.RATE_CHANGED, this.#cpuThrottlingRate);
+
+    // Propagate changes to the effective tier only if not manually overridden.
+    if (this.#manualCPUPerformanceOverride === undefined) {
+      this.#syncCPUPerformanceTier();
+      if (this.#hostDefaultCPUPerformanceTier === undefined) {
+        void this.updateHostDefaultCPUPerformanceTier();
+      }
+    }
   }
 
   setHardwareConcurrency(concurrency: number): void {
@@ -71,6 +234,10 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
     this.dispatchEventToListeners(Events.HARDWARE_CONCURRENCY_CHANGED, this.#hardwareConcurrency);
   }
 
+  setCPUPerformanceTier(tier?: CPUPerformanceTier): void {
+    this.#cpuPerformanceSetting.set(tier ?? 'no-override');
+  }
+
   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
@@ -114,6 +281,32 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
     return result.value;
   }
 
+  async updateHostDefaultCPUPerformanceTier(): Promise<void> {
+    if (this.#manualCPUPerformanceOverride !== undefined) {
+      // We do not want to update the host default tier when it is manually overridden
+      // via the sensors panel (in which case, `navigator.cpuPerformance` would return the override).
+      return;
+    }
+    const target = this.#targetManager.primaryPageTarget();
+    if (!target) {
+      return;
+    }
+    const evalResult = await target.runtimeAgent().invoke_evaluate(
+        {expression: 'navigator.cpuPerformance', returnByValue: true, silent: true, throwOnSideEffect: true});
+    if (evalResult.getError()) {
+      return;
+    }
+    const {result, exceptionDetails} = evalResult;
+    if (exceptionDetails || typeof result.value !== 'number') {
+      return;
+    }
+    const detectedTier = numberToTier(result.value);
+    if (this.#hostDefaultCPUPerformanceTier !== detectedTier) {
+      this.#hostDefaultCPUPerformanceTier = detectedTier;
+      this.#syncCPUPerformanceTier();
+    }
+  }
+
   modelAdded(emulationModel: EmulationModel): void {
     if (this.#cpuThrottlingRate !== 1) {
       void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingRate);
@@ -121,6 +314,9 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
     if (this.#hardwareConcurrency !== undefined) {
       void emulationModel.setHardwareConcurrency(this.#hardwareConcurrency);
     }
+    if (this.#isCPUPerformanceOverrideActive()) {
+      void emulationModel.setCPUPerformanceOverride(this.effectiveCPUPerformanceTier());
+    }
 
     // If there are any callers blocked on a getHardwareConcurrency call, let's wake them now.
     if (this.#pendingMainTargetPromise) {
@@ -138,9 +334,11 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
 export const enum Events {
   RATE_CHANGED = 'RateChanged',
   HARDWARE_CONCURRENCY_CHANGED = 'HardwareConcurrencyChanged',
+  CPU_PERFORMANCE_TIER_CHANGED = 'CpuPerformanceTierChanged',
 }
 
 export interface EventTypes {
   [Events.RATE_CHANGED]: number;
   [Events.HARDWARE_CONCURRENCY_CHANGED]: number;
+  [Events.CPU_PERFORMANCE_TIER_CHANGED]: CPUPerformanceTier|undefined;
 }

package/front_end/core/sdk/CSSMetadata.ts

@@ -392,7 +392,7 @@ export class CSSMetadata {
   }
 }
 
-export const CubicBezierKeywordValues = new Map([
+export const CubicBezierKeywordValues: Map<string, string> = new Map([
   ['linear', 'cubic-bezier(0, 0, 1, 1)'],
   ['ease', 'cubic-bezier(0.25, 0.1, 0.25, 1)'],
   ['ease-in', 'cubic-bezier(0.42, 0, 1, 1)'],
@@ -440,10 +440,14 @@ export const PositionTryOrderKeywords: PositionTryOrderKeyword[] = [
   PositionTryOrderKeyword.MOST_INLINE_SIZE,
 ];
 
-export const VariableNameRegex = /(\s*--.*?)/gs;
-export const VariableRegex = /(var\(\s*--.*?\))/gs;
-export const CustomVariableRegex = /(var\(*--[\w\d]+-([\w]+-[\w]+)\))/g;
-export const URLRegex = /url\(\s*('.+?'|".+?"|[^)]+)\s*\)/g;
+// eslint-disable-next-line @typescript-eslint/no-inferrable-types
+export const VariableNameRegex: RegExp = /(\s*--.*?)/gs;
+// eslint-disable-next-line @typescript-eslint/no-inferrable-types
+export const VariableRegex: RegExp = /(var\(\s*--.*?\))/gs;
+// eslint-disable-next-line @typescript-eslint/no-inferrable-types
+export const CustomVariableRegex: RegExp = /(var\(*--[\w\d]+-([\w]+-[\w]+)\))/g;
+// eslint-disable-next-line @typescript-eslint/no-inferrable-types
+export const URLRegex: RegExp = /url\(\s*('.+?'|".+?"|[^)]+)\s*\)/g;
 
 /**
  * Matches an instance of a grid area 'row' definition.
@@ -453,7 +457,8 @@ export const URLRegex = /url\(\s*('.+?'|".+?"|[^)]+)\s*\)/g;
  * 'grid', 'grid-template', e.g.
  *    [track-#name] "a a ." minmax(50px, auto) [track-#name]
  */
-export const GridAreaRowRegex = /((?:\[[\w\- ]+\]\s*)*(?:"[^"]+"|'[^']+'))[^'"\[]*\[?[^'"\[]*/;
+// eslint-disable-next-line @typescript-eslint/no-inferrable-types
+export const GridAreaRowRegex: RegExp = /((?:\[[\w\- ]+\]\s*)*(?:"[^"]+"|'[^']+'))[^'"\[]*\[?[^'"\[]*/;
 
 let cssMetadataInstance: CSSMetadata|null = null;
 

package/front_end/core/sdk/CSSPropertyParser.ts

@@ -189,8 +189,10 @@ export interface Matcher<MatchT extends Match> {
   matches(node: CodeMirror.SyntaxNode, matching: BottomUpTreeMatching): MatchT|null;
 }
 
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function matcherBase<MatchT extends Match>(matchT: Platform.Constructor.ConstructorOrAbstract<MatchT>) {
+export type MatcherClass<MatchT extends Match> = Platform.Constructor.Constructor<Matcher<MatchT>>;
+
+export function matcherBase<MatchT extends Match>(matchT: Platform.Constructor.ConstructorOrAbstract<MatchT>):
+    MatcherClass<MatchT> {
   class MatcherBase implements Matcher<MatchT> {
     matchType = matchT;
     accepts(_propertyName: string): boolean {
@@ -508,7 +510,7 @@ export function requiresSpace(a: Node[]|string|undefined, b: Node[]|string|undef
       !noSpaceBefore.includes(leadingChar);
 }
 
-export const CSSControlMap = Map<string, HTMLElement[]>;
+export const CSSControlMap: MapConstructor = Map;
 export type CSSControlMap = Map<string, HTMLElement[]>;
 export namespace ASTUtils {
   export function siblings(node: CodeMirror.SyntaxNode|null): CodeMirror.SyntaxNode[] {