chrome-devtools-frontend 1.0.1654411 → 1.0.1656897

package/front_end/panels/emulation/DeviceModeToolbar.ts

@@ -108,16 +108,9 @@ const UIStrings = {
   moreOptions: 'More options',
   /**
    * @description A menu item in the drop-down box that allows the user to select the zoom level.
-   * Labels the value which corresponds to the 'fit to window' zoom level, represented by the
-   * placeholder, which is a number. In the Device Mode Toolbar.
-   * @example {30.0} PH1
-   */
-  fitToWindowPercentage: '{PH1}% (fit to window)',
-  /**
-   * @description A checkbox setting that appears in the context menu for the zoom level, in the
-   * Device Mode Toolbar.
+   * Labels the option to automatically fit the preview to the available window space. In the Device Mode Toolbar.
    */
-  autoadjustZoom: 'Auto-adjust zoom',
+  fitToWindow: 'Fit to window',
   /**
    * @description A menu item in the drop-down box that allows the user to select the device pixel
    * ratio. Labels the default value which varies between device types, represented by the
@@ -236,7 +229,6 @@ const str_ = i18n.i18n.registerUIStrings('panels/emulation/DeviceModeToolbar.ts'
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 const {ifDefined, live} = Directives;
 const {widget} = UI.Widget;
-const {bindToSetting} = UI.UIUtils;
 
 export interface DeviceModeOption {
   device: EmulationModel.EmulatedDevices.EmulatedDevice;
@@ -359,17 +351,11 @@ export const DEFAULT_VIEW: View = (input, _output, target) => {
               title=${i18nString(UIStrings.zoom)}
               aria-label=${i18nString(UIStrings.zoom)}
               @change=${input.onScaleChange}
-              .value=${String(input.scaleOptions.find(o => o.selected)?.value || '')}
+              .value=${String(input.scaleOptions.find(o => o.selected)?.value ?? '')}
               jslog=${VisualLogging.dropDown().track({change: true}).context('scale')}>
         ${input.scaleOptions.map(o => html`<option value=${o.value} ?selected=${o.selected} jslog=${VisualLogging.item(o.jslogContext).track({click: true})}>${o.title}</option>`)}
       </select>
 
-      <devtools-button .data=${{variant: Buttons.Button.Variant.TOOLBAR, iconName: 'center-focus-weak',
-                                toggledIconName: 'center-focus-weak', toggleType: Buttons.Button.ToggleType.PRIMARY} as Buttons.Button.ButtonData}
-                       class="toolbar-button" title=${i18nString(UIStrings.autoadjustZoom)}
-                       ${bindToSetting(input.autoAdjustScaleSetting)}>
-      </devtools-button>
-
       <div class="device-mode-empty-toolbar-element"></div>
 
       ${input.showDeviceScaleFactorSetting.get() ? html`
@@ -381,7 +367,7 @@ export const DEFAULT_VIEW: View = (input, _output, target) => {
                     title=${i18nString(UIStrings.devicePixelRatio)}
                     aria-label=${i18nString(UIStrings.devicePixelRatio)}
                     @change=${input.onDeviceScaleChange}
-                    .value=${String(input.dprOptions.find(o => o.selected)?.value || '')}
+                    .value=${String(input.dprOptions.find(o => o.selected)?.value ?? '')}
                     jslog=${VisualLogging.dropDown().track({change: true}).context('device-pixel-ratio')}
                     ?disabled=${!input.isResponsive}>
                 ${input.dprOptions.map(o => html`<option value=${o.value} ?selected=${o.selected} jslog=${VisualLogging.item(o.jslogContext).track({click: true})}>${o.title}</option>`)}
@@ -488,6 +474,7 @@ export class DeviceModeToolbar extends UI.Widget.Widget {
 
     this.autoAdjustScaleSetting =
         Common.Settings.Settings.instance().createSetting('emulation.auto-adjust-scale', true);
+    this.autoAdjustScaleSetting.addChangeListener(this.requestUpdate, this);
 
     this.lastMode = new Map();
 
@@ -665,39 +652,53 @@ export class DeviceModeToolbar extends UI.Widget.Widget {
 
   private getScaleOptions(): Array<{title: string, value: number, selected: boolean, jslogContext: string}> {
     const values = [0.5, 0.75, 1, 1.25, 1.5, 2];
-    let fitValue: number|null = null;
-    if (this.model.type() === EmulationModel.DeviceModeModel.Type.Device) {
-      fitValue = this.model.fitScale();
-      const fitValuePct = (fitValue * 100).toFixed(0);
-      let found = false;
-      for (let i = 0; i < values.length; ++i) {
-        if ((values[i] * 100).toFixed(0) === fitValuePct) {
-          found = true;
-          values[i] = fitValue;
-          break;
-        }
-      }
-      if (!found) {
-        values.push(fitValue);
-        values.sort((a, b) => a - b);
-      }
+    const isAutoAdjusting = this.autoAdjustScaleSetting.get();
+    const currentScale = this.model.scaleSetting().get();
+
+    if (!isAutoAdjusting && !values.includes(currentScale)) {
+      values.push(currentScale);
+      values.sort((a, b) => a - b);
     }
 
-    const currentScale = this.model.scaleSetting().get();
-    return values.map(value => {
-      let title = (value * 100).toFixed(0) + '%';
-      let jslogContext = title;
-      if (value === fitValue) {
-        title = i18nString(UIStrings.fitToWindowPercentage, {PH1: (value * 100).toFixed(0)});
-        jslogContext = 'fit-to-window';
-      }
-      return {title, value, selected: currentScale === value, jslogContext};
-    });
+    const options: Array<{title: string, value: number, selected: boolean, jslogContext: string}> = [
+      {
+        title: i18nString(UIStrings.fitToWindow),
+        value: 0,
+        selected: isAutoAdjusting,
+        jslogContext: 'fit-to-window',
+      },
+    ];
+
+    for (const value of values) {
+      const title = (value * 100).toFixed(0) + '%';
+      options.push({
+        title,
+        value,
+        selected: !isAutoAdjusting && currentScale === value,
+        jslogContext: title,
+      });
+    }
+    return options;
   }
 
   private onScaleChange(event: Event): void {
     const value = Number((event.target as HTMLSelectElement).value);
-    this.model.scaleSetting().set(value);
+    if (value === 0) {
+      this.autoAdjustScaleSetting.set(true);
+      if (this.model.type() === EmulationModel.DeviceModeModel.Type.Responsive) {
+        const appliedSize = this.model.appliedDeviceSize();
+        this.model.setSizeAndScaleToFit(appliedSize.width, appliedSize.height);
+      } else {
+        const device = this.model.device();
+        const mode = this.model.mode();
+        if (device && mode) {
+          this.model.emulate(EmulationModel.DeviceModeModel.Type.Device, device, mode, undefined);
+        }
+      }
+    } else {
+      this.autoAdjustScaleSetting.set(false);
+      this.model.scaleSetting().set(value);
+    }
   }
 
   private getDeviceScaleFactorOptions():

package/front_end/panels/mobile_throttling/CalibrationController.ts

@@ -4,6 +4,7 @@
 
 import * as i18n from '../../core/i18n/i18n.js';
 import * as SDK from '../../core/sdk/sdk.js';
+import * as PanelsCommon from '../common/common.js';
 
 const UIStrings = {
   /**
@@ -55,7 +56,7 @@ export class CalibrationController {
   #runtimeModel!: SDK.RuntimeModel.RuntimeModel;
   #emulationModel!: SDK.EmulationModel.EmulationModel;
   #originalUrl!: string;
-  #result?: SDK.CPUThrottlingManager.CalibratedCPUThrottling;
+  #result?: PanelsCommon.CPUThrottlingOption.CalibratedCPUThrottling;
   #state: 'idle'|'running'|'aborting' = 'idle';
 
   /**
@@ -220,14 +221,14 @@ export class CalibrationController {
       if (actualScore < midScore) {
         if (actualScore < lowScore) {
           this.#result = {
-            low: SDK.CPUThrottlingManager.CalibrationError.DEVICE_TOO_WEAK,
-            mid: SDK.CPUThrottlingManager.CalibrationError.DEVICE_TOO_WEAK,
+            low: PanelsCommon.CPUThrottlingOption.CalibrationError.DEVICE_TOO_WEAK,
+            mid: PanelsCommon.CPUThrottlingOption.CalibrationError.DEVICE_TOO_WEAK,
           };
           return;
         }
 
         // Can still emulate the low-end device.
-        this.#result = {mid: SDK.CPUThrottlingManager.CalibrationError.DEVICE_TOO_WEAK};
+        this.#result = {mid: PanelsCommon.CPUThrottlingOption.CalibrationError.DEVICE_TOO_WEAK};
         isHalfwayDone = true;
       }
     }
@@ -258,7 +259,7 @@ export class CalibrationController {
     }
   }
 
-  result(): SDK.CPUThrottlingManager.CalibratedCPUThrottling|undefined {
+  result(): PanelsCommon.CPUThrottlingOption.CalibratedCPUThrottling|undefined {
     return this.#result;
   }
 

package/front_end/panels/mobile_throttling/MobileThrottlingSelector.ts

@@ -70,7 +70,7 @@ export class MobileThrottlingSelector {
     this.populateOptions();
 
     const networkConditions = SDK.NetworkManager.MultitargetNetworkManager.instance().networkConditions();
-    const cpuThrottlingOption = SDK.CPUThrottlingManager.CPUThrottlingManager.instance().cpuThrottlingOption();
+    const cpuThrottlingOption = throttlingManager().cpuThrottlingOption();
     for (let index = 0; index < this.options.length; ++index) {
       const option = this.options[index];
       if (option && 'network' in option && option.network === networkConditions &&

package/front_end/panels/mobile_throttling/ThrottlingManager.ts

@@ -11,6 +11,7 @@ import {Icon} from '../../ui/kit/kit.js';
 import * as UI from '../../ui/legacy/legacy.js';
 import {html, render} from '../../ui/lit/lit.js';
 import * as VisualLogging from '../../ui/visual_logging/visual_logging.js';
+import * as PanelsCommon from '../common/common.js';
 
 import {MobileThrottlingSelector} from './MobileThrottlingSelector.js';
 import {
@@ -22,7 +23,7 @@ import {
 
 export interface CPUThrottlingSelectorWrapper {
   control: UI.Toolbar.ToolbarComboBox;
-  updateRecommendedOption(recommendedOption: SDK.CPUThrottlingManager.CPUThrottlingOption|null): void;
+  updateRecommendedOption(recommendedOption: PanelsCommon.CPUThrottlingOption.CPUThrottlingOption|null): void;
 }
 
 const UIStrings = {
@@ -109,15 +110,17 @@ class PromiseQueue<T> {
 
 export class ThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<ThrottlingManager.EventTypes> {
   private readonly cpuThrottlingControls: Set<UI.Toolbar.ToolbarComboBox>;
-  private readonly cpuThrottlingOptions: SDK.CPUThrottlingManager.CPUThrottlingOption[];
+  private readonly cpuThrottlingOptions: PanelsCommon.CPUThrottlingOption.CPUThrottlingOption[];
   private readonly customNetworkConditionsSetting: Common.Settings.Setting<SDK.NetworkManager.Conditions[]>;
   private readonly currentNetworkThrottlingConditionKeySetting:
       Common.Settings.Setting<SDK.NetworkManager.ThrottlingConditionKey>;
   private readonly calibratedCpuThrottlingSetting:
-      Common.Settings.Setting<SDK.CPUThrottlingManager.CalibratedCPUThrottling>;
+      Common.Settings.Setting<PanelsCommon.CPUThrottlingOption.CalibratedCPUThrottling>;
   private lastNetworkThrottlingConditions!: SDK.NetworkManager.Conditions;
   private readonly cpuThrottlingManager: SDK.CPUThrottlingManager.CPUThrottlingManager;
   #hardwareConcurrencyOverrideEnabled = false;
+  #currentCPUThrottlingOption: PanelsCommon.CPUThrottlingOption.CPUThrottlingOption =
+      PanelsCommon.CPUThrottlingOption.NoThrottlingOption;
   readonly #emulationQueue = new PromiseQueue<void>();
   get hardwareConcurrencyOverrideEnabled(): boolean {
     return this.#hardwareConcurrencyOverrideEnabled;
@@ -136,8 +139,9 @@ export class ThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Thrott
     this.currentNetworkThrottlingConditionKeySetting = SDK.NetworkManager.activeNetworkThrottlingKeySetting();
 
     this.calibratedCpuThrottlingSetting =
-        Common.Settings.Settings.instance().createSetting<SDK.CPUThrottlingManager.CalibratedCPUThrottling>(
+        Common.Settings.Settings.instance().createSetting<PanelsCommon.CPUThrottlingOption.CalibratedCPUThrottling>(
             'calibrated-cpu-throttling', {}, Common.Settings.SettingStorageType.GLOBAL);
+    this.calibratedCpuThrottlingSetting.addChangeListener(this.onCalibratedSettingChanged, this);
 
     SDK.NetworkManager.MultitargetNetworkManager.instance().addEventListener(
         SDK.NetworkManager.MultitargetNetworkManager.Events.CONDITIONS_CHANGED, () => {
@@ -250,23 +254,46 @@ export class ThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Thrott
 
   private updatePanelIcon(): void {
     const warnings = [];
-    if (this.cpuThrottlingManager.cpuThrottlingRate() !== SDK.CPUThrottlingManager.CPUThrottlingRates.NO_THROTTLING) {
+    if (this.cpuThrottlingManager.cpuThrottlingRate() !==
+        PanelsCommon.CPUThrottlingOption.CPUThrottlingRates.NO_THROTTLING) {
       warnings.push(i18nString(UIStrings.cpuThrottlingIsEnabled));
     }
     UI.InspectorView.InspectorView.instance().setPanelWarnings('timeline', warnings);
   }
 
-  setCPUThrottlingOption(option: SDK.CPUThrottlingManager.CPUThrottlingOption): void {
-    // This will transitively call onCPUThrottlingRateChangedOnSDK.
-    this.cpuThrottlingManager.setCPUThrottlingOption(option);
+  cpuThrottlingOption(): PanelsCommon.CPUThrottlingOption.CPUThrottlingOption {
+    return this.#currentCPUThrottlingOption;
+  }
+
+  setCPUThrottlingOption(option: PanelsCommon.CPUThrottlingOption.CPUThrottlingOption): void {
+    if (this.#currentCPUThrottlingOption === option) {
+      return;
+    }
+    this.#currentCPUThrottlingOption = option;
+    this.cpuThrottlingManager.setCPUThrottlingRate(option.rate());
+  }
+
+  private onCalibratedSettingChanged(): void {
+    if (!this.#currentCPUThrottlingOption.calibratedDeviceType) {
+      return;
+    }
+    const rate = this.#currentCPUThrottlingOption.rate();
+    if (rate === 0) {
+      this.setCPUThrottlingOption(PanelsCommon.CPUThrottlingOption.NoThrottlingOption);
+      return;
+    }
+    this.cpuThrottlingManager.setCPUThrottlingRate(rate);
   }
 
   onCPUThrottlingRateChangedOnSDK(rate: number): void {
-    if (rate !== SDK.CPUThrottlingManager.CPUThrottlingRates.NO_THROTTLING) {
+    if (rate !== PanelsCommon.CPUThrottlingOption.CPUThrottlingRates.NO_THROTTLING) {
       Host.userMetrics.actionTaken(Host.UserMetrics.Action.CpuThrottlingEnabled);
     }
 
-    const index = this.cpuThrottlingOptions.indexOf(this.cpuThrottlingManager.cpuThrottlingOption());
+    const option = PanelsCommon.CPUThrottlingOption.determineOptionFromRate(rate, this.#currentCPUThrottlingOption);
+    this.#currentCPUThrottlingOption = option;
+
+    const index = this.cpuThrottlingOptions.indexOf(option);
     for (const control of this.cpuThrottlingControls) {
       control.setSelectedIndex(index);
     }
@@ -282,7 +309,7 @@ export class ThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Thrott
 
     const optionSelected = (): void => {
       if (control.selectedIndex() === control.options().length - 1) {
-        const index = this.cpuThrottlingOptions.indexOf(this.cpuThrottlingManager.cpuThrottlingOption());
+        const index = this.cpuThrottlingOptions.indexOf(this.#currentCPUThrottlingOption);
         control.setSelectedIndex(index);
         void Common.Revealer.reveal(this.calibratedCpuThrottlingSetting);
       } else {
@@ -293,7 +320,7 @@ export class ThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Thrott
     const control =
         new UI.Toolbar.ToolbarComboBox(optionSelected, i18nString(UIStrings.cpuThrottling), '', 'cpu-throttling');
     this.cpuThrottlingControls.add(control);
-    const currentOption = this.cpuThrottlingManager.cpuThrottlingOption();
+    const currentOption = this.#currentCPUThrottlingOption;
 
     const optionEls: HTMLOptionElement[] = [];
     const options = this.cpuThrottlingOptions;
@@ -317,7 +344,7 @@ export class ThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Thrott
 
     return {
       control,
-      updateRecommendedOption(recommendedOption: SDK.CPUThrottlingManager.CPUThrottlingOption|null) {
+      updateRecommendedOption(recommendedOption: PanelsCommon.CPUThrottlingOption.CPUThrottlingOption|null) {
         for (let i = 0; i < optionEls.length - 1; i++) {
           const option = options[i];
           optionEls[i].text = option === recommendedOption ?

package/front_end/panels/mobile_throttling/ThrottlingPresets.ts

@@ -4,6 +4,7 @@
 
 import * as i18n from '../../core/i18n/i18n.js';
 import * as SDK from '../../core/sdk/sdk.js';
+import * as PanelsCommon from '../common/common.js';
 
 const UIStrings = {
   /**
@@ -61,7 +62,7 @@ export class ThrottlingPresets {
       title,
       description: i18nString(UIStrings.noThrottling),
       network: SDK.NetworkManager.NoThrottlingConditions,
-      cpuThrottlingOption: SDK.CPUThrottlingManager.NoThrottlingOption,
+      cpuThrottlingOption: PanelsCommon.CPUThrottlingOption.NoThrottlingOption,
       jslogContext: 'no-throttling',
     };
   }
@@ -74,15 +75,16 @@ export class ThrottlingPresets {
       title,
       description: i18nString(UIStrings.noInternetConnectivity),
       network: SDK.NetworkManager.OfflineConditions,
-      cpuThrottlingOption: SDK.CPUThrottlingManager.NoThrottlingOption,
+      cpuThrottlingOption: PanelsCommon.CPUThrottlingOption.NoThrottlingOption,
       jslogContext: 'offline',
     };
   }
 
   static getLowEndMobileConditions(): Conditions {
-    const useCalibrated = SDK.CPUThrottlingManager.CalibratedLowTierMobileThrottlingOption.rate() !== 0;
-    const cpuThrottlingOption = useCalibrated ? SDK.CPUThrottlingManager.CalibratedLowTierMobileThrottlingOption :
-                                                SDK.CPUThrottlingManager.LowTierThrottlingOption;
+    const useCalibrated = PanelsCommon.CPUThrottlingOption.CalibratedLowTierMobileThrottlingOption.rate() !== 0;
+    const cpuThrottlingOption = useCalibrated ?
+        PanelsCommon.CPUThrottlingOption.CalibratedLowTierMobileThrottlingOption :
+        PanelsCommon.CPUThrottlingOption.LowTierThrottlingOption;
     const description = useCalibrated ?
         i18nString(UIStrings.slowGXCpuSlowdownCalibrated, {PH1: cpuThrottlingOption.rate()}) :
         i18nString(UIStrings.slowGXCpuSlowdown);
@@ -97,9 +99,10 @@ export class ThrottlingPresets {
   }
 
   static getMidTierMobileConditions(): Conditions {
-    const useCalibrated = SDK.CPUThrottlingManager.CalibratedMidTierMobileThrottlingOption.rate() !== 0;
-    const cpuThrottlingOption = useCalibrated ? SDK.CPUThrottlingManager.CalibratedMidTierMobileThrottlingOption :
-                                                SDK.CPUThrottlingManager.MidTierThrottlingOption;
+    const useCalibrated = PanelsCommon.CPUThrottlingOption.CalibratedMidTierMobileThrottlingOption.rate() !== 0;
+    const cpuThrottlingOption = useCalibrated ?
+        PanelsCommon.CPUThrottlingOption.CalibratedMidTierMobileThrottlingOption :
+        PanelsCommon.CPUThrottlingOption.MidTierThrottlingOption;
     const description = useCalibrated ?
         i18nString(UIStrings.fastGXCpuSlowdownCalibrated, {PH1: cpuThrottlingOption.rate()}) :
         i18nString(UIStrings.fastGXCpuSlowdown);
@@ -142,14 +145,7 @@ export class ThrottlingPresets {
     SDK.NetworkManager.OfflineConditions,
   ];
 
-  static cpuThrottlingPresets: SDK.CPUThrottlingManager.CPUThrottlingOption[] = [
-    SDK.CPUThrottlingManager.NoThrottlingOption,
-    SDK.CPUThrottlingManager.MidTierThrottlingOption,
-    SDK.CPUThrottlingManager.LowTierThrottlingOption,
-    SDK.CPUThrottlingManager.ExtraSlowThrottlingOption,
-    SDK.CPUThrottlingManager.CalibratedLowTierMobileThrottlingOption,
-    SDK.CPUThrottlingManager.CalibratedMidTierMobileThrottlingOption,
-  ];
+  static cpuThrottlingPresets = PanelsCommon.CPUThrottlingOption.cpuThrottlingPresets;
 }
 
 // @ts-expect-error exported for Tests.js
@@ -161,7 +157,7 @@ export interface Conditions {
   title: string;
   description: string;
   network: SDK.NetworkManager.Conditions;
-  cpuThrottlingOption: SDK.CPUThrottlingManager.CPUThrottlingOption;
+  cpuThrottlingOption: PanelsCommon.CPUThrottlingOption.CPUThrottlingOption;
   jslogContext?: string;
 }
 

package/front_end/panels/mobile_throttling/ThrottlingSettingsTab.ts

@@ -12,6 +12,7 @@ import * as Buttons from '../../ui/components/buttons/buttons.js';
 import {type Card, createIcon} from '../../ui/kit/kit.js';
 import * as UI from '../../ui/legacy/legacy.js';
 import * as VisualLogging from '../../ui/visual_logging/visual_logging.js';
+import * as PanelsCommon from '../common/common.js';
 
 import {CalibrationController} from './CalibrationController.js';
 import {ThrottlingPresets} from './ThrottlingPresets.js';
@@ -214,7 +215,7 @@ function createComputePressurePromise(): Promise<{state: string}> {
 export class CPUThrottlingCard {
   element: Card;
 
-  private readonly setting: Common.Settings.Setting<SDK.CPUThrottlingManager.CalibratedCPUThrottling>;
+  private readonly setting: Common.Settings.Setting<PanelsCommon.CPUThrottlingOption.CalibratedCPUThrottling>;
   private computePressurePromise?: ReturnType<typeof createComputePressurePromise>;
   private controller?: CalibrationController;
 
@@ -230,8 +231,9 @@ export class CPUThrottlingCard {
   private warnings: string[] = [];
 
   constructor() {
-    this.setting = Common.Settings.Settings.instance().createSetting<SDK.CPUThrottlingManager.CalibratedCPUThrottling>(
-        'calibrated-cpu-throttling', {}, Common.Settings.SettingStorageType.GLOBAL);
+    this.setting =
+        Common.Settings.Settings.instance().createSetting<PanelsCommon.CPUThrottlingOption.CalibratedCPUThrottling>(
+            'calibrated-cpu-throttling', {}, Common.Settings.SettingStorageType.GLOBAL);
 
     this.element = document.createElement('devtools-card');
     this.element.heading = i18nString(UIStrings.cpuThrottlingPresets);
@@ -331,13 +333,13 @@ export class CPUThrottlingCard {
       this.progress.style.display = '';
     }
 
-    const resultToString = (result: number|SDK.CPUThrottlingManager.CalibrationError|undefined): string => {
+    const resultToString = (result: number|PanelsCommon.CPUThrottlingOption.CalibrationError|undefined): string => {
       if (result === undefined) {
         return i18nString(UIStrings.needsCalibration);
       }
 
       if (typeof result === 'string') {
-        return SDK.CPUThrottlingManager.calibrationErrorToString(result);
+        return PanelsCommon.CPUThrottlingOption.calibrationErrorToString(result);
       }
 
       // Shouldn't happen, but let's not throw an error (.toFixed) if the setting
@@ -349,15 +351,15 @@ export class CPUThrottlingCard {
       return i18nString(UIStrings.dSlowdown, {PH1: result.toFixed(1)});
     };
 
-    const setPresetResult =
-        (element: HTMLElement|null, result: number|SDK.CPUThrottlingManager.CalibrationError|undefined): void => {
-          if (!element) {
-            throw new Error('expected HTMLElement');
-          }
+    const setPresetResult = (element: HTMLElement|null,
+                             result: number|PanelsCommon.CPUThrottlingOption.CalibrationError|undefined): void => {
+      if (!element) {
+        throw new Error('expected HTMLElement');
+      }
 
-          element.textContent = resultToString(result);
-          element.classList.toggle('not-calibrated', result === undefined);
-        };
+      element.textContent = resultToString(result);
+      element.classList.toggle('not-calibrated', result === undefined);
+    };
 
     setPresetResult(this.lowTierMobileDeviceEl.querySelector('.cpu-preset-result'), result.low);
     setPresetResult(this.midTierMobileDeviceEl.querySelector('.cpu-preset-result'), result.mid);

package/front_end/panels/network/NetworkLogView.ts

@@ -41,7 +41,6 @@ import * as i18n from '../../core/i18n/i18n.js';
 import * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
-import * as Annotations from '../../models/annotations/annotations.js';
 import * as Bindings from '../../models/bindings/bindings.js';
 import * as HAR from '../../models/har/har.js';
 import * as Logs from '../../models/logs/logs.js';
@@ -998,14 +997,6 @@ export class NetworkLogView extends Common.ObjectWrapper.eventMixin<EventTypes,
     return this.summaryToolbarInternal;
   }
 
-  getDataGrid(): DataGrid.SortableDataGrid.SortableDataGrid<NetworkNode>|null {
-    if (Annotations.AnnotationRepository.annotationsEnabled()) {
-      return this.dataGrid;
-    }
-
-    return null;
-  }
-
   modelAdded(networkManager: SDK.NetworkManager.NetworkManager): void {
     // TODO(allada) Remove dependency on networkManager and instead use NetworkLog and PageLoad for needed data.
     const target = networkManager.target();

package/front_end/panels/network/NetworkPanel.ts

@@ -40,12 +40,11 @@ import * as Host from '../../core/host/host.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
-import * as Annotations from '../../models/annotations/annotations.js';
 import * as Logs from '../../models/logs/logs.js';
 import * as NetworkTimeCalculator from '../../models/network_time_calculator/network_time_calculator.js';
 import * as Trace from '../../models/trace/trace.js';
 import * as Workspace from '../../models/workspace/workspace.js';
-import * as PanelCommon from '../../panels/common/common.js';
+import type * as PanelCommon from '../../panels/common/common.js';
 import * as NetworkForward from '../../panels/network/forward/forward.js';
 import * as Tracing from '../../services/tracing/tracing.js';
 import * as PerfUI from '../../ui/legacy/components/perf_ui/perf_ui.js';
@@ -340,14 +339,6 @@ export class NetworkPanel extends UI.Panel.Panel implements
          HTMLElement);
     panel.element.appendChild(this.fileSelectorElement);
 
-    if (Annotations.AnnotationRepository.annotationsEnabled()) {
-      const dataGrid = this.networkLogView.getDataGrid();
-      if (dataGrid) {
-        PanelCommon.AnnotationManager.instance().initializePlacementForAnnotationType(
-            Annotations.AnnotationType.NETWORK_REQUEST, this.resolveInitialState.bind(this), dataGrid.scrollContainer);
-      }
-    }
-
     this.detailsWidget = new UI.Widget.VBox();
     this.detailsWidget.element.classList.add('network-details-view');
     this.splitWidget.setMainWidget(this.detailsWidget);
@@ -661,11 +652,6 @@ export class NetworkPanel extends UI.Panel.Panel implements
 
     // Record the network tool load time after the panel has loaded.
     UI.UIUserMetrics.UIUserMetrics.instance().panelLoaded('network', 'DevTools.Launch.Network');
-
-    if (Annotations.AnnotationRepository.annotationsEnabled()) {
-      void PanelCommon.AnnotationManager.instance().resolveAnnotationsOfType(
-          Annotations.AnnotationType.NETWORK_REQUEST);
-    }
   }
 
   override willHide(): void {
@@ -765,47 +751,6 @@ export class NetworkPanel extends UI.Panel.Panel implements
     return this.networkItemView;
   }
 
-  async resolveInitialState(
-      parentElement: Element, reveal: boolean, lookupId: string,
-      anchor?: SDK.DOMModel.DOMNode|SDK.NetworkRequest.NetworkRequest): Promise<{x: number, y: number}|null> {
-    let request = anchor as SDK.NetworkRequest.NetworkRequest;
-    if (!this.isShowing()) {
-      return null;
-    }
-
-    if (!request) {
-      const networkManager =
-          SDK.TargetManager.TargetManager.instance().scopeTarget()?.model(SDK.NetworkManager.NetworkManager);
-      if (!networkManager) {
-        return null;
-      }
-
-      const requests = Logs.NetworkLog.NetworkLog.instance().requestsForId(lookupId);
-      if (requests.length === 0) {
-        console.warn('Network Request list is empty');
-        return null;
-      }
-      request = requests[0];
-    }
-
-    if (reveal) {
-      await Common.Revealer.reveal(request);
-      await this.selectAndActivateRequest(request);
-    }
-
-    const requestNode = this.networkLogView?.nodeForRequest(request);
-    if (requestNode?.element()) {
-      const targetRect = requestNode.element().getBoundingClientRect();
-      const parentRect = parentElement.getBoundingClientRect();
-      const relativeX = 4;
-      const relativeY = targetRect.y - parentRect.y + parentElement.scrollTop;
-      return {x: relativeX, y: relativeY};
-    }
-
-    console.warn('Could not find element for request:', anchor);
-    return null;
-  }
-
   private updateUI(): void {
     if (this.detailsWidget) {
       this.detailsWidget.element.classList.toggle(
@@ -905,13 +850,6 @@ export class NetworkPanel extends UI.Panel.Panel implements
         Trace.Types.Timing.Milli(this.calculator.minimumBoundary() * 1000),
         Trace.Types.Timing.Milli(this.calculator.maximumBoundary() * 1000));
     this.networkOverview.updateRequest(request);
-
-    if (Annotations.AnnotationRepository.annotationsEnabled()) {
-      requestAnimationFrame(() => {
-        void PanelCommon.AnnotationManager.instance().resolveAnnotationsOfType(
-            Annotations.AnnotationType.NETWORK_REQUEST);
-      });
-    }
   }
 
   resolveLocation(locationName: string): UI.View.ViewLocation|null {