chrome-devtools-frontend 1.0.1473514 → 1.0.1506453

package/front_end/core/common/Settings.test.ts

@@ -2,29 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import {MockStore} from '../../testing/MockSettingStorage.js';
+
 import * as Common from './common.js';
 
 const SettingsStorage = Common.Settings.SettingsStorage;
 const VersionController = Common.Settings.VersionController;
 
-class MockStore implements Common.Settings.SettingsBackingStore {
-  #store = new Map();
-  register() {
-  }
-  set(key: string, value: string) {
-    this.#store.set(key, value);
-  }
-  get(key: string) {
-    return this.#store.get(key);
-  }
-  remove(key: string) {
-    this.#store.delete(key);
-  }
-  clear() {
-    this.#store.clear();
-  }
-}
-
 describe('SettingsStorage class', () => {
   it('is able to set a name', () => {
     const settingsStorage = new SettingsStorage({});
@@ -680,6 +664,155 @@ describe('updateVersionFrom38To39', () => {
     versionController.updateVersionFrom38To39();
     assert.isFalse(settings.globalStorage.has('preferred-network-condition'));
   });
+
+  describe('updateVersionFrom39To40', () => {
+    let settings: Common.Settings.Settings;
+    let customNetworkCondSetting: Common.Settings.Setting<Array<{key?: string}>>;
+    let preferredNetworkCondSetting: Common.Settings.Setting<{i18nTitleKey: string}>;
+
+    beforeEach(() => {
+      const mockStore = new MockStore();
+      const syncedStorage = new Common.Settings.SettingsStorage({}, mockStore);
+      const globalStorage = new Common.Settings.SettingsStorage({}, mockStore);
+      const localStorage = new Common.Settings.SettingsStorage({}, mockStore);
+
+      Common.Settings.registerSettingExtension({
+        settingName: 'custom-network-conditions',
+        settingType: Common.Settings.SettingType.ARRAY,
+        defaultValue: [],
+      });
+
+      settings = Common.Settings.Settings.instance({
+        forceNew: true,
+        syncedStorage,
+        globalStorage,
+        localStorage,
+      });
+      customNetworkCondSetting = settings.moduleSetting('custom-network-conditions');
+      preferredNetworkCondSetting = settings.createSetting('preferred-network-condition', {i18nTitleKey: 'Offline'});
+    });
+
+    afterEach(() => {
+      Common.Settings.Settings.removeInstance();
+      Common.Settings.resetSettings();  // Clear SettingsRegistrations.
+    });
+
+    it('updates all settings to have a key', () => {
+      // In reality these values are SDK.NetworkManager.Conditions but we
+      // cannot refer to SDK here, and for this test we are only testing the
+      // addition of the key which does not care about the data in the
+      // object.
+      customNetworkCondSetting.set([{}, {}]);
+      const versionController = new VersionController();
+      versionController.updateVersionFrom39To40();
+      assert.deepEqual(customNetworkCondSetting.get(), [
+        {
+          key: 'USER_CUSTOM_SETTING_1',
+        },
+        {
+          key: 'USER_CUSTOM_SETTING_2',
+        }
+      ]);
+    });
+
+    it('does not update settings that have a key already', () => {
+      customNetworkCondSetting.set([{key: 'KEY'}]);
+      const versionController = new VersionController();
+      versionController.updateVersionFrom39To40();
+      assert.deepEqual(customNetworkCondSetting.get(), [
+        {
+          key: 'KEY',
+        },
+      ]);
+    });
+
+    it('migrates users who have a preferred-network-condition set to "Fast 4G"', () => {
+      preferredNetworkCondSetting.set({i18nTitleKey: 'Fast 4G'});
+      const versionController = new VersionController();
+      versionController.updateVersionFrom39To40();
+
+      const activeKeySetting = settings.globalStorage.get('active-network-condition-key');
+      assert.strictEqual(activeKeySetting, JSON.stringify('SPEED_FAST_4G'));
+      assert.isFalse(settings.globalStorage.has('preferred-network-condition'));
+    });
+
+    it('migrates users who have a preferred-network-condition set to "Slow 4G"', () => {
+      preferredNetworkCondSetting.set({i18nTitleKey: 'Slow 4G'});
+      const versionController = new VersionController();
+      versionController.updateVersionFrom39To40();
+
+      const activeKeySetting = settings.globalStorage.get('active-network-condition-key');
+      assert.strictEqual(activeKeySetting, JSON.stringify('SPEED_SLOW_4G'));
+      assert.isFalse(settings.globalStorage.has('preferred-network-condition'));
+    });
+
+    it('migrates users who have a preferred-network-condition set to "Slow 4G"', () => {
+      preferredNetworkCondSetting.set({i18nTitleKey: 'Slow 4G'});
+      const versionController = new VersionController();
+      versionController.updateVersionFrom39To40();
+
+      const activeKeySetting = settings.globalStorage.get('active-network-condition-key');
+      assert.strictEqual(activeKeySetting, JSON.stringify('SPEED_SLOW_4G'));
+      assert.isFalse(settings.globalStorage.has('preferred-network-condition'));
+    });
+
+    it('migrates users who have a preferred-network-condition set to "3G"', () => {
+      preferredNetworkCondSetting.set({i18nTitleKey: '3G'});
+      const versionController = new VersionController();
+      versionController.updateVersionFrom39To40();
+
+      const activeKeySetting = settings.globalStorage.get('active-network-condition-key');
+      assert.strictEqual(activeKeySetting, JSON.stringify('SPEED_3G'));
+      assert.isFalse(settings.globalStorage.has('preferred-network-condition'));
+    });
+
+    it('migrates users who have a preferred-network-condition set to "Offline"', () => {
+      preferredNetworkCondSetting.set({i18nTitleKey: 'Offline'});
+      const versionController = new VersionController();
+      versionController.updateVersionFrom39To40();
+
+      const activeKeySetting = settings.globalStorage.get('active-network-condition-key');
+      assert.strictEqual(activeKeySetting, JSON.stringify('OFFLINE'));
+      assert.isFalse(settings.globalStorage.has('preferred-network-condition'));
+    });
+
+    it('sets the default setting value correctly to No Throttling', () => {
+      preferredNetworkCondSetting.set({i18nTitleKey: 'Offline'});
+      const versionController = new VersionController();
+      versionController.updateVersionFrom39To40();
+
+      const activeKeySetting = settings.globalStorage.get('active-network-condition-key');
+      assert.strictEqual(activeKeySetting, JSON.stringify('OFFLINE'));
+
+      const newSetting = Common.Settings.Settings.instance().createSetting('active-network-condition-key', 'INVALID');
+      assert.strictEqual(newSetting.defaultValue, 'NO_THROTTLING');
+
+      assert.isFalse(settings.globalStorage.has('preferred-network-condition'));
+    });
+
+    it('migrates users who have a preferred-network-condition set to "No throttling"', () => {
+      preferredNetworkCondSetting.set({i18nTitleKey: 'No throttling'});
+      const versionController = new VersionController();
+      versionController.updateVersionFrom39To40();
+
+      const activeKeySetting = settings.globalStorage.get('active-network-condition-key');
+      assert.strictEqual(activeKeySetting, JSON.stringify('NO_THROTTLING'));
+      assert.isFalse(settings.globalStorage.has('preferred-network-condition'));
+    });
+
+    it('ignores any unexpected values and just deletes the old setting', () => {
+      preferredNetworkCondSetting.set({i18nTitleKey: 'Not a valid key'});
+      const versionController = new VersionController();
+      versionController.updateVersionFrom39To40();
+
+      // Ensure it does not create the new setting, ensuring that it will be
+      // created when the user next navigates to the network / perf panel.
+      assert.isFalse(settings.globalStorage.has('active-network-condition-key'));
+
+      // We still get rid of the old value.
+      assert.isFalse(settings.globalStorage.has('preferred-network-condition'));
+    });
+  });
 });
 
 describe('access logging', () => {

package/front_end/core/common/Settings.ts

@@ -179,9 +179,9 @@ export class Settings {
 
   /**
    * Get setting via key, and create a new setting if the requested setting does not exist.
-   * @param {string} key kebab-case string ID
-   * @param {T} defaultValue
-   * @param {SettingStorageType=} storageType If not specified, SettingStorageType.GLOBAL is used.
+   * @param key kebab-case string ID
+   * @param defaultValue
+   * @param storageType If not specified, SettingStorageType.GLOBAL is used.
    */
   createSetting<T>(key: string, defaultValue: T, storageType?: SettingStorageType): Setting<T> {
     const storage = this.storageFromType(storageType);
@@ -674,7 +674,7 @@ export class VersionController {
   static readonly SYNCED_VERSION_SETTING_NAME = 'syncedInspectorVersion';
   static readonly LOCAL_VERSION_SETTING_NAME = 'localInspectorVersion';
 
-  static readonly CURRENT_VERSION = 39;
+  static readonly CURRENT_VERSION = 40;
 
   readonly #globalVersionSetting: Setting<number>;
   readonly #syncedVersionSetting: Setting<number>;
@@ -1359,6 +1359,93 @@ export class VersionController {
     }
   }
 
+  /**
+   * There are two related migrations here for handling network throttling persistence:
+   * 1. Go through all user custom throttling conditions and add a `key` property.
+   * 2. If the user has a 'preferred-network-condition' setting, take the value
+   *    of that and set the right key for the new 'active-network-condition-key'
+   *    setting. Then, remove the now-obsolete 'preferred-network-condition'
+   *    setting.
+   */
+  updateVersionFrom39To40(): void {
+    const hasCustomNetworkConditionsSetting = (): boolean => {
+      try {
+        // this will error if it does not exist
+        moduleSetting('custom-network-conditions');
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    if (hasCustomNetworkConditionsSetting()) {
+      /**
+       * We added keys to custom network throttling conditions in M140, so we
+       * need to go through any existing profiles the user has and add the key to
+       * them.
+       * We can't use the SDK.NetworkManager.Condition here as it would be a
+       * circular dependency. All that matters is that these conditions are
+       * objects, and we need to set the right key on each one. The actual keys &
+       * values in the object are not important.
+       */
+      const conditionsSetting = moduleSetting('custom-network-conditions') as Setting<Array<{key?: string}>>;
+      const customConditions = conditionsSetting.get();
+      if (customConditions?.length > 0) {
+        customConditions.forEach((condition, i) => {
+          // This could be run multiple times, make sure that we don't override any
+          // existing keys.
+          if (condition.key) {
+            return;
+          }
+          // The format of this key is important: see
+          // SDK.NetworkManager.UserDefinedThrottlingConditionKey
+          condition.key = `USER_CUSTOM_SETTING_${i + 1}`;
+        });
+        conditionsSetting.set(customConditions);
+      }
+    }
+
+    // Additionally, we need to make sure we persist the right throttling for
+    // users who have a preferred-network-condition set.
+    const PREFERRED_NETWORK_COND_SETTING = 'preferred-network-condition';
+    // We shipped a change to how we persist network throttling conditions and
+    // added a `key` property rather than rely on any user visible string which
+    // is more likely to change. This migration step tries to update the
+    // setting for users, or removes it if we fail, so they start fresh next
+    // time they load DevTools.
+    const setting = Settings.instance().globalStorage.get(PREFERRED_NETWORK_COND_SETTING);
+    if (!setting) {
+      return;
+    }
+    // The keys here are the UI Strings as of July 2025 (shipped in M139).
+    // This migration shipped in M140. The values are the values of the
+    // `PredefinedThrottlingConditionKey` in SDK.NetworkManager.
+    const UI_STRING_TO_NEW_KEY = {
+      'Fast 4G': 'SPEED_FAST_4G',
+      'Slow 4G': 'SPEED_SLOW_4G',
+      '3G': 'SPEED_3G',
+      'No throttling': 'NO_THROTTLING',
+      Offline: 'OFFLINE'
+    };
+    try {
+      const networkSetting = JSON.parse(setting) as unknown as {
+        // Can't use SDK type here as it creates a common<>sdk circular
+        // dep. We only rely on the i18nTitleKey.
+        i18nTitleKey?: string,
+      };
+      if (networkSetting.i18nTitleKey && UI_STRING_TO_NEW_KEY.hasOwnProperty(networkSetting.i18nTitleKey)) {
+        const key = UI_STRING_TO_NEW_KEY[networkSetting.i18nTitleKey as keyof typeof UI_STRING_TO_NEW_KEY];
+
+        // The second argument is the default value, so it's important that we
+        // set this to the default, and then update it to the new key.
+        const newSetting = Settings.instance().createSetting('active-network-condition-key', 'NO_THROTTLING');
+        newSetting.set(key);
+      }
+    } finally {
+      // This setting is now not used, so we can remove it.
+      Settings.instance().globalStorage.remove(PREFERRED_NETWORK_COND_SETTING);
+    }
+  }
+
   /*
    * Any new migration should be added before this comment.
    *
@@ -1409,13 +1496,17 @@ export class VersionController {
 export const enum SettingStorageType {
   /** Persists with the active Chrome profile but also syncs the settings across devices via Chrome Sync. */
   SYNCED = 'Synced',
-  /** Persists with the active Chrome profile, but not synchronized to other devices.
-   * The default SettingStorageType of createSetting(). */
+  /**
+   * Persists with the active Chrome profile, but not synchronized to other devices.
+   * The default SettingStorageType of createSetting().
+   */
   GLOBAL = 'Global',
   /** Uses Window.localStorage. Not recommended, legacy. */
   LOCAL = 'Local',
-  /** Session storage dies when DevTools window closes. Useful for atypical conditions that should be reverted when the
-   * user is done with their task. (eg Emulation modes, Debug overlays). These are also not carried into/out of incognito */
+  /**
+   * Session storage dies when DevTools window closes. Useful for atypical conditions that should be reverted when the
+   * user is done with their task. (eg Emulation modes, Debug overlays). These are also not carried into/out of incognito
+   */
   SESSION = 'Session',
 }
 

package/front_end/core/common/SimpleHistoryManager.ts

@@ -91,23 +91,6 @@ export class SimpleHistoryManager {
     return Boolean(this.#coalescingReadonly);
   }
 
-  filterOut(filterOutCallback: (arg0: HistoryEntry) => boolean): void {
-    if (this.readOnly()) {
-      return;
-    }
-    const filteredEntries = [];
-    let removedBeforeActiveEntry = 0;
-    for (let i = 0; i < this.#entries.length; ++i) {
-      if (!filterOutCallback(this.#entries[i])) {
-        filteredEntries.push(this.#entries[i]);
-      } else if (i <= this.#activeEntryIndex) {
-        ++removedBeforeActiveEntry;
-      }
-    }
-    this.#entries = filteredEntries;
-    this.#activeEntryIndex = Math.max(0, this.#activeEntryIndex - removedBeforeActiveEntry);
-  }
-
   empty(): boolean {
     return !this.#entries.length;
   }

package/front_end/core/common/common.ts

@@ -12,6 +12,7 @@ import * as ColorUtils from './ColorUtils.js';
 import * as Console from './Console.js';
 import * as Debouncer from './Debouncer.js';
 import * as EventTarget from './EventTarget.js';
+import * as Gzip from './Gzip.js';
 import * as JavaScriptMetaData from './JavaScriptMetaData.js';
 import * as Lazy from './Lazy.js';
 import * as Linkifier from './Linkifier.js';
@@ -23,6 +24,7 @@ import * as Progress from './Progress.js';
 import * as QueryParamHandler from './QueryParamHandler.js';
 import * as ResolverBase from './ResolverBase.js';
 import * as ResourceType from './ResourceType.js';
+import * as ReturnToPanel from './ReturnToPanel.js';
 import * as Revealer from './Revealer.js';
 import * as Runnable from './Runnable.js';
 import * as SegmentedRange from './SegmentedRange.js';
@@ -52,6 +54,7 @@ export {
   Console,
   Debouncer,
   EventTarget,
+  Gzip,
   JavaScriptMetaData,
   Lazy,
   Linkifier,
@@ -63,6 +66,7 @@ export {
   QueryParamHandler,
   ResolverBase,
   ResourceType,
+  ReturnToPanel,
   Revealer,
   Runnable,
   SegmentedRange,

package/front_end/core/host/AidaClient.test.ts

@@ -10,6 +10,7 @@ import {
 } from '../../testing/EnvironmentHelpers.js';
 
 import * as Host from './host.js';
+import type {AidaCodeCompleteResult} from './InspectorFrontendHostAPI.js';
 
 const TEST_MODEL_ID = 'testModelId';
 
@@ -197,9 +198,10 @@ describeWithEnvironment('AidaClient', () => {
     });
   });
 
-  async function getAllResults(provider: Host.AidaClient.AidaClient): Promise<Host.AidaClient.AidaResponse[]> {
+  async function getAllResults(provider: Host.AidaClient.AidaClient):
+      Promise<Host.AidaClient.DoConversationResponse[]> {
     const results = [];
-    for await (const result of provider.fetch(Host.AidaClient.AidaClient.buildConsoleInsightsRequest('foo'))) {
+    for await (const result of provider.doConversation(Host.AidaClient.AidaClient.buildConsoleInsightsRequest('foo'))) {
       results.push(result);
     }
     return results;
@@ -627,4 +629,103 @@ describeWithEnvironment('AidaClient', () => {
       }));
     });
   });
+
+  describe('completeCode', () => {
+    beforeEach(() => {
+      sinon.restore();
+    });
+
+    it('handles successful response', async () => {
+      const mockResult: AidaCodeCompleteResult = {
+        response: JSON.stringify({
+          generatedSamples: [{
+            generationString: 'console.log("hello");',
+            score: 0.9,
+            sampleId: 1,
+            metadata: {
+              attributionMetadata: {
+                attributionAction: 'CITE',
+                citations: [{startIndex: 0, endIndex: 1, uri: 'https://example.com'}],
+              },
+            },
+          }],
+          metadata: {
+            rpcGlobalId: 456,
+          },
+        }),
+      };
+      sinon.stub(Host.InspectorFrontendHost.InspectorFrontendHostInstance, 'aidaCodeComplete')
+          .callsArgWith(1, mockResult);
+
+      const provider = new Host.AidaClient.AidaClient();
+      const request: Host.AidaClient.CompletionRequest = {
+        client: 'CHROME_DEVTOOLS',
+        prefix: 'console.log("',
+        metadata: {
+          disable_user_content_logging: false,
+          client_version: 'unit_test',
+        },
+      };
+      const result = await provider.completeCode(request);
+
+      assert.deepEqual(result, {
+        generatedSamples: [{
+          generationString: 'console.log("hello");',
+          score: 0.9,
+          sampleId: 1,
+          attributionMetadata: {
+            attributionAction: Host.AidaClient.RecitationAction.CITE,
+            citations: [{startIndex: 0, endIndex: 1, uri: 'https://example.com'}]
+          },
+        }],
+        metadata: {
+          rpcGlobalId: 456,
+        },
+      });
+    });
+
+    it('throws on error from the host', async () => {
+      sinon.stub(Host.InspectorFrontendHost.InspectorFrontendHostInstance, 'aidaCodeComplete').callsArgWith(1, {
+        error: 'Cannot get OAuth credentials',
+        detail: '{\'@type\': \'type.googleapis.com/google.rpc.DebugInfo\', \'detail\': \'DETAILS\'}',
+      });
+      const provider = new Host.AidaClient.AidaClient();
+      try {
+        const request: Host.AidaClient.CompletionRequest = {
+          client: 'CHROME_DEVTOOLS',
+          prefix: 'console.log("',
+          metadata: {
+            disable_user_content_logging: false,
+            client_version: 'unit_test',
+          },
+        };
+        await provider.completeCode(request);
+      } catch (err) {
+        expect(err.message)
+            .equals(
+                'Cannot send request: Cannot get OAuth credentials {\'@type\': \'type.googleapis.com/google.rpc.DebugInfo\', \'detail\': \'DETAILS\'}');
+      }
+    });
+
+    it('throws on empty response from the host', async () => {
+      sinon.stub(Host.InspectorFrontendHost.InspectorFrontendHostInstance, 'aidaCodeComplete').callsArgWith(1, {
+        response: '',
+      });
+
+      const provider = new Host.AidaClient.AidaClient();
+      const request: Host.AidaClient.CompletionRequest = {
+        client: 'CHROME_DEVTOOLS',
+        prefix: 'console.log("',
+        metadata: {
+          disable_user_content_logging: false,
+          client_version: 'unit_test',
+        },
+      };
+      try {
+        await provider.completeCode(request);
+      } catch (err) {
+        expect(err.message).equals('Empty response');
+      }
+    });
+  });
 });