chrome-devtools-frontend 1.0.1402249 → 1.0.1418433

package/front_end/panels/linear_memory_inspector/components/valueInterpreterDisplay.css

@@ -65,4 +65,5 @@
 
 .selectable-text::selection {
   background-color: var(--sys-color-tonal-container);
+  color: currentcolor;
 }

package/front_end/panels/media/EventDisplayTable.ts

@@ -76,6 +76,7 @@ export class PlayerEventsView extends UI.Widget.VBox {
 
   constructor() {
     super();
+    this.registerRequiredCSS(eventDisplayTableStyles);
 
     this.element.setAttribute('jslog', `${VisualLogging.pane('events')}`);
 
@@ -143,7 +144,7 @@ export class PlayerEventsView extends UI.Widget.VBox {
       if (isAtBottom) {
         scroll.scrollTop = scroll.scrollHeight;
       }
-    } catch (e) {
+    } catch {
       // If this is a legacy message event, ignore it for now until they
       // are handled.
     }
@@ -165,8 +166,4 @@ export class PlayerEventsView extends UI.Widget.VBox {
       sort: DataGrid.DataGrid.Order.Ascending,
     } as DataGrid.DataGrid.ColumnDescriptor;
   }
-  override wasShown(): void {
-    super.wasShown();
-    this.registerCSSFiles([eventDisplayTableStyles]);
-  }
 }

package/front_end/panels/media/EventTimelineView.ts

@@ -30,9 +30,9 @@ const UIStrings = {
 const str_ = i18n.i18n.registerUIStrings('panels/media/EventTimelineView.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
-type State = {
-  [key: string]: string,
-};
+interface State {
+  [key: string]: string;
+}
 
 export class PlayerEventsTimeline extends TickingFlameChart {
   private normalizedTimestamp: number;

package/front_end/panels/media/MediaModel.ts

@@ -20,13 +20,13 @@ export const enum Events {
   PLAYERS_CREATED = 'PlayersCreated',
 }
 
-export type EventTypes = {
-  [Events.PLAYER_PROPERTIES_CHANGED]: Protocol.Media.PlayerPropertiesChangedEvent,
-  [Events.PLAYER_EVENTS_ADDED]: Protocol.Media.PlayerEventsAddedEvent,
-  [Events.PLAYER_MESSAGES_LOGGED]: Protocol.Media.PlayerMessagesLoggedEvent,
-  [Events.PLAYER_ERRORS_RAISED]: Protocol.Media.PlayerErrorsRaisedEvent,
-  [Events.PLAYERS_CREATED]: Protocol.Media.PlayerId[],
-};
+export interface EventTypes {
+  [Events.PLAYER_PROPERTIES_CHANGED]: Protocol.Media.PlayerPropertiesChangedEvent;
+  [Events.PLAYER_EVENTS_ADDED]: Protocol.Media.PlayerEventsAddedEvent;
+  [Events.PLAYER_MESSAGES_LOGGED]: Protocol.Media.PlayerMessagesLoggedEvent;
+  [Events.PLAYER_ERRORS_RAISED]: Protocol.Media.PlayerErrorsRaisedEvent;
+  [Events.PLAYERS_CREATED]: Protocol.Media.PlayerId[];
+}
 
 export class MediaModel extends SDK.SDKModel.SDKModel<EventTypes> implements ProtocolProxyApi.MediaDispatcher {
   private enabled: boolean;

package/front_end/panels/media/PlayerListView.ts

@@ -53,6 +53,7 @@ export class PlayerListView extends UI.Widget.VBox implements TriggerDispatcher
 
   constructor(mainContainer: MainView) {
     super(true);
+    this.registerRequiredCSS(playerListViewStyles);
 
     this.playerEntryFragments = new Map();
     this.playerEntriesWithHostnameFrameTitle = new Set();
@@ -250,9 +251,4 @@ export class PlayerListView extends UI.Widget.VBox implements TriggerDispatcher
   onMessage(_playerID: string, _message: Protocol.Media.PlayerMessage): void {
     // TODO(tmathmeyer) show a message count number next to the player name.
   }
-
-  override wasShown(): void {
-    super.wasShown();
-    this.registerCSSFiles([playerListViewStyles]);
-  }
 }

package/front_end/panels/media/PlayerMessagesView.ts

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import '../../ui/legacy/legacy.js';
+
 import type * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import type * as Protocol from '../../generated/protocol.js';
@@ -221,7 +223,7 @@ class MessageLevelSelector implements UI.SoftDropDown.Delegate<SelectableLevel>
 
   createElementForItem(item: SelectableLevel): Element {
     const element = document.createElement('div');
-    const shadowRoot = UI.UIUtils.createShadowRootWithCoreStyles(element, {cssFile: [playerMessagesViewStyles]});
+    const shadowRoot = UI.UIUtils.createShadowRootWithCoreStyles(element, {cssFile: playerMessagesViewStyles});
     const container = shadowRoot.createChild('div', 'media-messages-level-dropdown-element');
     const checkBox = container.createChild('div', 'media-messages-level-dropdown-checkbox');
     const text = container.createChild('span', 'media-messages-level-dropdown-text');
@@ -255,6 +257,7 @@ export class PlayerMessagesView extends UI.Widget.VBox {
 
   constructor() {
     super();
+    this.registerRequiredCSS(playerMessagesViewStyles);
 
     this.element.setAttribute('jslog', `${VisualLogging.pane('messages')}`);
 
@@ -265,7 +268,7 @@ export class PlayerMessagesView extends UI.Widget.VBox {
   }
 
   private buildToolbar(): void {
-    const toolbar = new UI.Toolbar.Toolbar('media-messages-toolbar', this.headerPanel);
+    const toolbar = this.headerPanel.createChild('devtools-toolbar', 'media-messages-toolbar');
     toolbar.appendText(i18nString(UIStrings.logLevel));
     toolbar.appendToolbarItem(this.createDropdown());
     toolbar.appendSeparator();
@@ -396,9 +399,4 @@ export class PlayerMessagesView extends UI.Widget.VBox {
     const container = this.bodyPanel.createChild('div', 'media-messages-message-container media-message-error');
     container.appendChild(this.errorToDiv(error));
   }
-
-  override wasShown(): void {
-    super.wasShown();
-    this.registerCSSFiles([playerMessagesViewStyles]);
-  }
 }

package/front_end/panels/media/PlayerPropertiesView.ts

@@ -136,9 +136,9 @@ const str_ = i18n.i18n.registerUIStrings('panels/media/PlayerPropertiesView.ts',
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
 
-type TabData = {
-  [x: string]: string|object,
-};
+interface TabData {
+  [x: string]: string|object;
+}
 
 // Keep this enum in sync with panels/media/base/media_log_properties.h
 export const enum PlayerPropertyKeys {
@@ -195,7 +195,7 @@ export class PropertyRenderer extends UI.Widget.VBox {
     }
     try {
       propvalue = JSON.parse(propvalue) as string;
-    } catch (err) {
+    } catch {
       // TODO(tmathmeyer) typecheck the type of propvalue against
       // something defined or sourced from the c++ definitions.
       // Do nothing, some strings just stay strings!
@@ -477,6 +477,7 @@ export class PlayerPropertiesView extends UI.Widget.VBox {
 
   constructor() {
     super();
+    this.registerRequiredCSS(playerPropertiesViewStyles);
 
     this.element.setAttribute('jslog', `${VisualLogging.pane('properties')}`);
 
@@ -668,8 +669,4 @@ export class PlayerPropertiesView extends UI.Widget.VBox {
     const textTrackManager = new TextTrackManager(this);
     this.attributeMap.set(PlayerPropertyKeys.TEXT_TRACKS, textTrackManager);
   }
-  override wasShown(): void {
-    super.wasShown();
-    this.registerCSSFiles([playerPropertiesViewStyles]);
-  }
 }

package/front_end/panels/mobile_throttling/CalibrationController.ts

@@ -0,0 +1,368 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as i18n from '../../core/i18n/i18n.js';
+import * as SDK from '../../core/sdk/sdk.js';
+
+const UIStrings = {
+  /**
+   *@description Text to display to user while a calibration process is running.
+   */
+  runningCalibration: 'Running CPU calibration, please do not leave this tab or close DevTools.',
+};
+const str_ = i18n.i18n.registerUIStrings('panels/mobile_throttling/CalibrationController.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+
+/**
+ * How long each iteration of the Lighthouse BenchmarkIndex benchmark runs for.
+ * This benchmark runs multiple times throughout the calibration process.
+ *
+ * The entire calibration process has an upper-bound of running the benchmark 20 times:
+ *   - 1 to "warm up" v8
+ *   - 1 to check if device is powerful enough
+ *   - up to 9 for each preset (uses bisect, so likely to be fewer)
+ *
+ * Therefore, the maxium duration for the calibration is 5 seconds.
+ */
+const benchmarkDurationMs = 250;
+
+/**
+ * The benchmark score of a mid-tier device (like a Pixel 5).
+ */
+const midScore = 1000;
+
+/**
+ * The benchmark score of a low-tier device (like a Moto G4 Power 2022).
+ */
+const lowScore = 264;
+
+function truncate(n: number): number {
+  return Number(n.toFixed(2));
+}
+
+/**
+ * Runs a calibration process to determine ideal CPU throttling rates to target a low-tier and mid-tier device.
+ *
+ * Utilizes a benchmark from Lighthouse (LH BenchmarkIndex) to assess performance. This CPU benchmark serves as
+ * a simple alias for device performance - but since results aren't exactly linear with clock speed a "bisect"
+ * is run to find the ideal DevTools CPU throttling rate to recieve the same results on the benchmark.
+ *
+ * @see go/cpq:adaptive-throttling
+ * @see https://github.com/connorjclark/devtools-throttling-benchmarks/blob/main/calibrate.js
+ */
+export class CalibrationController {
+  #runtimeModel!: SDK.RuntimeModel.RuntimeModel;
+  #emulationModel!: SDK.EmulationModel.EmulationModel;
+  #originalUrl!: string;
+  #result?: SDK.CPUThrottlingManager.CalibratedCPUThrottling;
+  #state: 'idle'|'running'|'aborting' = 'idle';
+
+  /**
+   * The provided `benchmarkDuration` is how long each iteration of the Lighthouse BenchmarkIndex
+   * benchmark takes to run. This benchmark will run multiple times throughout the calibration process.
+   */
+  async start(): Promise<boolean> {
+    const primaryPageTarget = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
+    if (!primaryPageTarget) {
+      return false;
+    }
+
+    const runtimeModel = primaryPageTarget.model(SDK.RuntimeModel.RuntimeModel);
+    const emulationModel = primaryPageTarget.model(SDK.EmulationModel.EmulationModel);
+    if (!runtimeModel || !emulationModel) {
+      return false;
+    }
+
+    this.#state = 'running';
+    this.#runtimeModel = runtimeModel;
+    this.#emulationModel = emulationModel;
+    this.#originalUrl = primaryPageTarget.inspectedURL();
+
+    function setupTestPage(text: string): void {
+      const textEl = document.createElement('span');
+      textEl.textContent = text;
+
+      document.body.append(textEl);
+      document.body.style.cssText = `
+        font-family: system-ui, sans-serif;
+        height: 100vh;
+        margin: 0;
+        background-color: antiquewhite;
+        font-size: 18px;
+        text-align: center;
+
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      `;
+
+      const moonEl = document.createElement('span');
+      document.body.append(moonEl);
+      moonEl.id = 'moon';
+      moonEl.textContent = '🌑';
+      moonEl.style.cssText = 'font-size: 5em';
+    }
+
+    await primaryPageTarget.pageAgent().invoke_navigate({url: 'about:blank'});
+
+    await runtimeModel.agent.invoke_evaluate({
+      expression: `
+          (${setupTestPage})(${JSON.stringify(i18nString(UIStrings.runningCalibration))});
+
+          window.runBenchmark = () => {
+            window.runs = window.runs ?? 0;
+            moon.textContent = ['🌑', '🌒', '🌓', '🌔', '🌕', '🌖', '🌗', '🌘'][window.runs++ % 8];
+            return (${computeBenchmarkIndex})(${benchmarkDurationMs});
+          }`,
+    });
+
+    // Warm up - give v8 a change to optimize.
+    await this.#benchmark();
+
+    return true;
+  }
+
+  async #throttle(rate: number): Promise<void> {
+    if (this.#state !== 'running') {
+      this.#result = undefined;
+      throw new Error('Calibration has been canceled');
+    }
+
+    await this.#emulationModel.setCPUThrottlingRate(rate);
+  }
+
+  async #benchmark(): Promise<number> {
+    if (this.#state !== 'running') {
+      this.#result = undefined;
+      throw new Error('Calibration has been canceled');
+    }
+
+    const {result} = await this.#runtimeModel.agent.invoke_evaluate({
+      expression: 'runBenchmark()',
+    });
+    if (!Number.isFinite(result.value)) {
+      let err = `unexpected score from benchmark: ${result.value}`;
+      if (result.description) {
+        err += `\n${result.description}`;
+      }
+      throw new Error(err);
+    }
+    return result.value;
+  }
+
+  async * iterator(): AsyncGenerator<{progress: number}, void> {
+    const controller = this;
+
+    let isHalfwayDone = false;
+    yield {progress: 0};
+
+    const scoreCache = new Map<number, number>();
+    async function run(rate: number): Promise<number> {
+      const cached = scoreCache.get(rate);
+      if (cached !== undefined) {
+        return cached;
+      }
+
+      await controller.#throttle(rate);
+      const score = await controller.#benchmark();
+      scoreCache.set(rate, score);
+      return score;
+    }
+
+    /**
+     * Perform a binary bisect to find a CPU rate that results in the benchmark closely matching the target score.
+     */
+    async function*
+        find(target: number, lowerRate: number, upperRate: number): AsyncGenerator<{progress: number}, number> {
+      const lower = {rate: lowerRate, score: await run(lowerRate)};
+      const upper = {rate: upperRate, score: await run(upperRate)};
+
+      let rate = 0;
+      let iterations = 0;
+      const maxIterations = 8;
+      while (iterations++ < maxIterations) {
+        // The throttling agent backend truncates values to the hundredths place (aka 1%).
+        rate = truncate((upper.rate + lower.rate) / 2);
+        const score = await run(rate);
+
+        // Within 10 points is close enough for a match.
+        if (Math.abs(target - score) < 10) {
+          break;
+        }
+
+        if (score < target) {
+          upper.rate = rate;
+          upper.score = score;
+        } else {
+          lower.rate = rate;
+          lower.score = score;
+        }
+
+        yield {progress: iterations / maxIterations / 2 + (isHalfwayDone ? 0.5 : 0)};
+      }
+
+      return truncate(rate);
+    }
+
+    this.#result = {};
+
+    // Check if developer's device is weaker than the target devices.
+    let actualScore = await run(1);
+    if (actualScore < midScore) {
+      // Give it one more chance ...
+      scoreCache.clear();
+      actualScore = await run(1);
+      if (actualScore < midScore) {
+        if (actualScore < lowScore) {
+          this.#result = {
+            low: SDK.CPUThrottlingManager.CalibrationError.DEVICE_TOO_WEAK,
+            mid: SDK.CPUThrottlingManager.CalibrationError.DEVICE_TOO_WEAK,
+          };
+          return;
+        }
+
+        // Can still emulate the low-end device.
+        this.#result = {mid: SDK.CPUThrottlingManager.CalibrationError.DEVICE_TOO_WEAK};
+        isHalfwayDone = true;
+      }
+    }
+
+    const initialLowerRate = 1;
+    const initialUpperRate = actualScore / lowScore * 1.5;
+
+    const low = yield* find(lowScore, initialLowerRate, initialUpperRate);
+    this.#result.low = low;
+
+    if (!this.#result.mid) {
+      isHalfwayDone = true;
+      yield {progress: 0.5};
+
+      // "bootstrap" the bisect by using the results for the low-tier calibration.
+      const midToLowRatio = midScore / lowScore;
+      const r = low / midToLowRatio;
+      const mid = yield* find(midScore, r - r / 4, r + r / 4);
+      this.#result.mid = mid;
+    }
+
+    yield {progress: 1};
+  }
+
+  abort(): void {
+    if (this.#state === 'running') {
+      this.#state = 'aborting';
+    }
+  }
+
+  result(): SDK.CPUThrottlingManager.CalibratedCPUThrottling|undefined {
+    return this.#result;
+  }
+
+  async end(): Promise<void> {
+    if (this.#state === 'idle') {
+      return;
+    }
+
+    this.#state = 'idle';
+
+    if (this.#originalUrl.startsWith('chrome://')) {
+      await this.#runtimeModel.agent.invoke_evaluate({
+        expression: 'history.back()',
+      });
+    } else {
+      await this.#runtimeModel.agent.invoke_evaluate({
+        expression: `window.location.href = ${JSON.stringify(this.#originalUrl)}`,
+      });
+    }
+  }
+}
+
+/**
+ * Lifted from Lighthouse.
+ *
+ * Computes a memory/CPU performance benchmark index to determine rough device class.
+ * @see https://github.com/GoogleChrome/lighthouse/issues/9085
+ * @see https://docs.google.com/spreadsheets/d/1E0gZwKsxegudkjJl8Fki_sOwHKpqgXwt8aBAfuUaB8A/edit?usp=sharing
+ *
+ * Historically (until LH 6.3), this benchmark created a string of length 100,000 in a loop, and returned
+ * the number of times per second the string can be created.
+ *
+ * Changes to v8 in 8.6.106 changed this number and also made Chrome more variable w.r.t GC interupts.
+ * This benchmark now is a hybrid of a similar GC-heavy approach to the original benchmark and an array
+ * copy benchmark.
+ *
+ * As of Chrome m86...
+ *
+ *  - 1000+ is a desktop-class device, Core i3 PC, iPhone X, etc
+ *  - 800+ is a high-end Android phone, Galaxy S8, low-end Chromebook, etc
+ *  - 125+ is a mid-tier Android phone, Moto G4, etc
+ *  - <125 is a budget Android phone, Alcatel Ideal, Galaxy J2, etc
+ * @return {number}
+ */
+function computeBenchmarkIndex(duration = 1000): number {
+  const halfTime = duration / 2;
+
+  /**
+   * The GC-heavy benchmark that creates a string of length 10000 in a loop.
+   * The returned index is the number of times per second the string can be created divided by 10.
+   * The division by 10 is to keep similar magnitudes to an earlier version of BenchmarkIndex that
+   * used a string length of 100000 instead of 10000.
+   */
+  function benchmarkIndexGC(): number {
+    const start = Date.now();
+    let iterations = 0;
+
+    while (Date.now() - start < halfTime) {
+      let s = '';
+      for (let j = 0; j < 10000; j++) {
+        s += 'a';
+      }
+      if (s.length === 1) {
+        throw new Error('will never happen, but prevents compiler optimizations');
+      }
+
+      iterations++;
+    }
+
+    const durationInSeconds = (Date.now() - start) / 1000;
+    return Math.round(iterations / 10 / durationInSeconds);
+  }
+
+  /**
+   * The non-GC-dependent benchmark that copies integers back and forth between two arrays of length 100000.
+   * The returned index is the number of times per second a copy can be made, divided by 10.
+   * The division by 10 is to keep similar magnitudes to the GC-dependent version.
+   */
+  function benchmarkIndexNoGC(): number {
+    const arrA = [];
+    const arrB = [];
+    for (let i = 0; i < 100000; i++) {
+      arrA[i] = arrB[i] = i;
+    }
+
+    const start = Date.now();
+    let iterations = 0;
+
+    // Some Intel CPUs have a performance cliff due to unlucky JCC instruction alignment.
+    // Two possible fixes: call Date.now less often, or manually unroll the inner loop a bit.
+    // We'll call Date.now less and only check the duration on every 10th iteration for simplicity.
+    // See https://bugs.chromium.org/p/v8/issues/detail?id=10954#c1.
+    while (iterations % 10 !== 0 || Date.now() - start < halfTime) {
+      const src = iterations % 2 === 0 ? arrA : arrB;
+      const tgt = iterations % 2 === 0 ? arrB : arrA;
+
+      for (let j = 0; j < src.length; j++) {
+        tgt[j] = src[j];
+      }
+
+      iterations++;
+    }
+
+    const durationInSeconds = (Date.now() - start) / 1000;
+    return Math.round(iterations / 10 / durationInSeconds);
+  }
+
+  // The final BenchmarkIndex is a simple average of the two components.
+  return (benchmarkIndexGC() + benchmarkIndexNoGC()) / 2;
+}

package/front_end/panels/mobile_throttling/MobileThrottlingSelector.ts

@@ -6,7 +6,6 @@ import * as i18n from '../../core/i18n/i18n.js';
 import * as SDK from '../../core/sdk/sdk.js';
 
 import {throttlingManager} from './ThrottlingManager.js';
-
 import {
   ThrottlingPresets,
   type Conditions,
@@ -54,7 +53,7 @@ export class MobileThrottlingSelector {
 
   optionSelected(conditions: Conditions): void {
     SDK.NetworkManager.MultitargetNetworkManager.instance().setNetworkConditions(conditions.network);
-    throttlingManager().setCPUThrottlingRate(conditions.cpuThrottlingRate);
+    throttlingManager().setCPUThrottlingOption(conditions.cpuThrottlingOption);
   }
 
   private populateOptions(): ConditionsList {
@@ -68,12 +67,14 @@ export class MobileThrottlingSelector {
   }
 
   private conditionsChanged(): void {
+    this.populateOptions();
+
     const networkConditions = SDK.NetworkManager.MultitargetNetworkManager.instance().networkConditions();
-    const cpuThrottlingRate = SDK.CPUThrottlingManager.CPUThrottlingManager.instance().cpuThrottlingRate();
+    const cpuThrottlingOption = SDK.CPUThrottlingManager.CPUThrottlingManager.instance().cpuThrottlingOption();
     for (let index = 0; index < this.options.length; ++index) {
       const option = this.options[index];
       if (option && 'network' in option && option.network === networkConditions &&
-          option.cpuThrottlingRate === cpuThrottlingRate) {
+          option.cpuThrottlingOption === cpuThrottlingOption) {
         this.selectCallback(index);
         return;
       }

package/front_end/panels/mobile_throttling/ThrottlingManager.test.ts

@@ -66,18 +66,16 @@ describeWithEnvironment('ThrottlingManager', () => {
       const cpuThrottlingPresets = MobileThrottling.ThrottlingPresets.ThrottlingPresets.cpuThrottlingPresets;
       const throttlingManager = MobileThrottling.ThrottlingManager.throttlingManager();
       const selector = throttlingManager.createCPUThrottlingSelector().control;
-      assert.strictEqual(
-          cpuThrottlingPresets[selector.selectedIndex()], SDK.CPUThrottlingManager.CPUThrottlingRates.NO_THROTTLING);
+      assert.strictEqual(cpuThrottlingPresets[selector.selectedIndex()], SDK.CPUThrottlingManager.NoThrottlingOption);
 
-      SDK.CPUThrottlingManager.CPUThrottlingManager.instance().setCPUThrottlingRate(
-          SDK.CPUThrottlingManager.CPUThrottlingRates.EXTRA_SLOW);
+      SDK.CPUThrottlingManager.CPUThrottlingManager.instance().setCPUThrottlingOption(
+          SDK.CPUThrottlingManager.ExtraSlowThrottlingOption);
       assert.strictEqual(
-          cpuThrottlingPresets[selector.selectedIndex()], SDK.CPUThrottlingManager.CPUThrottlingRates.EXTRA_SLOW);
+          cpuThrottlingPresets[selector.selectedIndex()], SDK.CPUThrottlingManager.ExtraSlowThrottlingOption);
 
-      SDK.CPUThrottlingManager.CPUThrottlingManager.instance().setCPUThrottlingRate(
-          SDK.CPUThrottlingManager.CPUThrottlingRates.NO_THROTTLING);
-      assert.strictEqual(
-          cpuThrottlingPresets[selector.selectedIndex()], SDK.CPUThrottlingManager.CPUThrottlingRates.NO_THROTTLING);
+      SDK.CPUThrottlingManager.CPUThrottlingManager.instance().setCPUThrottlingOption(
+          SDK.CPUThrottlingManager.NoThrottlingOption);
+      assert.strictEqual(cpuThrottlingPresets[selector.selectedIndex()], SDK.CPUThrottlingManager.NoThrottlingOption);
     });
   });
 });