chrome-devtools-frontend 1.0.1530564 → 1.0.1531367

package/front_end/core/sdk/NetworkManager.ts

@@ -531,7 +531,7 @@ export const Fast4GConditions: Conditions = {
   targetLatency: fast4GTargetLatency,
 };
 
-const MAX_EAGER_POST_REQUEST_BODY_LENGTH = 64 * 1024;  // bytes
+const MAX_EAGER_POST_REQUEST_BODY_LENGTH = 64 * 1024;             // bytes
 const MAX_RESPONSE_BODY_TOTAL_BUFFER_LENGTH = 250 * 1024 * 1024;  // bytes
 
 export class FetchDispatcher implements ProtocolProxyApi.FetchDispatcher {
@@ -1566,11 +1566,12 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
   }
 }
 
-type RequestConditionsSetting = {
+export type RequestConditionsSetting = {
   url: string,
   enabled: boolean,
 }|{
   urlPattern: URLPatternConstructorString,
+  conditions: ThrottlingConditionKey,
   enabled: boolean,
 };
 
@@ -1648,21 +1649,40 @@ export class RequestURLPattern {
 export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<RequestCondition.EventTypes> {
   #pattern: RequestURLPattern|{wildcardURL: string, upgradedPattern?: RequestURLPattern};
   #enabled: boolean;
+  #conditions: ThrottlingConditions;
 
-  constructor(setting: RequestConditionsSetting) {
-    super();
+  static createFromSetting(setting: RequestConditionsSetting): RequestCondition {
     if ('urlPattern' in setting) {
-      this.#pattern = RequestURLPattern.create(setting.urlPattern) ?? {
+      const pattern = RequestURLPattern.create(setting.urlPattern) ?? {
         wildcardURL: setting.urlPattern,
         upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.urlPattern) ?? undefined,
       };
-    } else {
-      this.#pattern = {
-        wildcardURL: setting.url,
-        upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.url) ?? undefined
-      };
+
+      const conditions = getPredefinedOrBlockingCondition(setting.conditions) ??
+          customUserNetworkConditionsSetting().get().find(condition => condition.key === setting.conditions) ??
+          NoThrottlingConditions;
+
+      return new this(pattern, setting.enabled, conditions);
     }
-    this.#enabled = setting.enabled;
+
+    const pattern = {
+      wildcardURL: setting.url,
+      upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.url) ?? undefined
+    };
+    return new this(pattern, setting.enabled, BlockingConditions);
+  }
+
+  static create(pattern: RequestURLPattern, conditions: ThrottlingConditions): RequestCondition {
+    return new this(pattern, /* enabled=*/ true, conditions);
+  }
+
+  private constructor(
+      pattern: RequestURLPattern|{wildcardURL: string, upgradedPattern?: RequestURLPattern}, enabled: boolean,
+      conditions: ThrottlingConditions) {
+    super();
+    this.#pattern = pattern;
+    this.#enabled = enabled;
+    this.#conditions = conditions;
   }
 
   get constructorString(): string|undefined {
@@ -1705,10 +1725,24 @@ export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<Request
     this.dispatchEventToListeners(RequestCondition.Events.REQUEST_CONDITION_CHANGED);
   }
 
+  get conditions(): ThrottlingConditions {
+    return this.#conditions;
+  }
+
+  set conditions(conditions: ThrottlingConditions) {
+    this.#conditions = conditions;
+    this.dispatchEventToListeners(RequestCondition.Events.REQUEST_CONDITION_CHANGED);
+  }
+
   toSetting(): RequestConditionsSetting {
     const enabled = this.enabled;
-    return this.#pattern instanceof RequestURLPattern ? {enabled, urlPattern: this.#pattern.constructorString} :
-                                                        {enabled, url: this.#pattern.wildcardURL};
+    if (this.#pattern instanceof RequestURLPattern) {
+      return {enabled, urlPattern: this.#pattern.constructorString, conditions: this.#conditions.key};
+    }
+    if (this.#conditions !== BlockingConditions && this.#pattern.upgradedPattern) {
+      return {enabled, urlPattern: this.#pattern.upgradedPattern.constructorString, conditions: this.#conditions.key};
+    }
+    return {enabled, url: this.#pattern.wildcardURL};
   }
 
   get originalOrUpgradedURLPattern(): URLPattern|undefined {
@@ -1729,20 +1763,41 @@ export namespace RequestCondition {
 export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<RequestConditions.EventTypes> {
   readonly #setting =
       Common.Settings.Settings.instance().createSetting<RequestConditionsSetting[]>('network-blocked-patterns', []);
-  readonly #conditions: RequestCondition[];
+  readonly #conditionsEnabledSetting =
+      Common.Settings.Settings.instance().moduleSetting<boolean>('request-blocking-enabled');
+  readonly #conditions: RequestCondition[] = [];
 
   constructor() {
     super();
-    this.#conditions = this.#setting.get().map(condition => new RequestCondition(condition));
+    for (const condition of this.#setting.get()) {
+      try {
+        this.#conditions.push(RequestCondition.createFromSetting(condition));
+      } catch (e) {
+        console.error('Error loading throttling settings: ', e);
+      }
+    }
     for (const condition of this.#conditions) {
       condition.addEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
     }
+    this.#conditionsEnabledSetting.addChangeListener(
+        () => this.dispatchEventToListeners(RequestConditions.Events.REQUEST_CONDITIONS_CHANGED));
   }
 
   get count(): number {
     return this.#conditions.length;
   }
 
+  get conditionsEnabled(): boolean {
+    return this.#conditionsEnabledSetting.get();
+  }
+
+  set conditionsEnabled(enabled: boolean) {
+    if (this.#conditionsEnabledSetting.get() === enabled) {
+      return;
+    }
+    this.#conditionsEnabledSetting.set(enabled);
+  }
+
   findCondition(pattern: string): RequestCondition|undefined {
     if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
       return this.#conditions.find(condition => condition.constructorString === pattern);
@@ -1756,6 +1811,9 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
 
   add(...conditions: RequestCondition[]): void {
     this.#conditions.push(...conditions);
+    for (const condition of conditions) {
+      condition.addEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
+    }
     this.#conditionsChanged();
   }
 
@@ -1765,7 +1823,7 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
       return;
     }
     condition.removeEventListener(RequestCondition.Events.REQUEST_CONDITION_CHANGED, this.#conditionsChanged, this);
-    this.#conditions.splice(index);
+    this.#conditions.splice(index, 1);
     this.#conditionsChanged();
   }
 
@@ -1786,18 +1844,69 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
     return this.#conditions.values();
   }
 
-  applyConditions(...agents: ProtocolProxyApi.NetworkApi[]): boolean {
+  applyConditions(offline: boolean, globalConditions: Conditions|null, ...agents: ProtocolProxyApi.NetworkApi[]):
+      boolean {
+    function isNonBlockingCondition(condition: ThrottlingConditions): condition is Conditions {
+      return !('block' in condition);
+    }
     if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
-      const urlPatterns = this.#conditions.filter(condition => condition.enabled && condition.constructorString)
-                              .map(condition => ({urlPattern: condition.constructorString as string, block: true}));
+      const urlPatterns: Protocol.Network.BlockPattern[] = [];
+      const matchedNetworkConditions: Protocol.Network.NetworkConditions[] = [];
+      if (this.conditionsEnabled) {
+        for (const condition of this.#conditions) {
+          const urlPattern = condition.constructorString;
+          const conditions = condition.conditions;
+          if (!condition.enabled || !urlPattern || conditions === NoThrottlingConditions) {
+            continue;
+          }
+          const block = !isNonBlockingCondition(conditions);
+          urlPatterns.push({urlPattern, block});
+          if (!block) {
+            matchedNetworkConditions.push({
+              urlPattern,
+              latency: conditions.latency,
+              downloadThroughput: conditions.download < 0 ? 0 : conditions.download,
+              uploadThroughput: conditions.upload < 0 ? 0 : conditions.upload,
+              packetLoss: (conditions.packetLoss ?? 0) < 0 ? 0 : conditions.packetLoss,
+              packetQueueLength: conditions.packetQueueLength,
+              packetReordering: conditions.packetReordering,
+              connectionType: NetworkManager.connectionType(conditions),
+            });
+          }
+        }
+
+        if (globalConditions) {
+          matchedNetworkConditions.push({
+            urlPattern: '',
+            latency: globalConditions.latency,
+            downloadThroughput: globalConditions.download < 0 ? 0 : globalConditions.download,
+            uploadThroughput: globalConditions.upload < 0 ? 0 : globalConditions.upload,
+            packetLoss: (globalConditions.packetLoss ?? 0) < 0 ? 0 : globalConditions.packetLoss,
+            packetQueueLength: globalConditions.packetQueueLength,
+            packetReordering: globalConditions.packetReordering,
+            connectionType: NetworkManager.connectionType(globalConditions),
+          });
+        }
+      }
 
       for (const agent of agents) {
         void agent.invoke_setBlockedURLs({urlPatterns});
+        void agent.invoke_emulateNetworkConditionsByRule({offline, matchedNetworkConditions});
+        void agent.invoke_overrideNetworkState({
+          offline,
+          latency: globalConditions?.latency ?? 0,
+          downloadThroughput: !globalConditions || globalConditions.download < 0 ? 0 : globalConditions.download,
+          uploadThroughput: !globalConditions || globalConditions.upload < 0 ? 0 : globalConditions.upload,
+        });
       }
       return urlPatterns.length > 0;
     }
-    const urls = this.#conditions.filter(condition => condition.enabled && condition.wildcardURL)
-                     .map(condition => condition.wildcardURL as string);
+
+    const urls = this.conditionsEnabled ?
+        this.#conditions.filter(condition => condition.enabled && condition.wildcardURL)
+            .map(condition => condition.wildcardURL as string) :
+        [];
+
     for (const agent of agents) {
       void agent.invoke_setBlockedURLs({urls});
     }
@@ -1826,8 +1935,6 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
   readonly inflightMainResourceRequests = new Map<string, NetworkRequest>();
   #networkConditions: Conditions = NoThrottlingConditions;
   #updatingInterceptionPatternsPromise: Promise<void>|null = null;
-  readonly #blockingEnabledSetting =
-      Common.Settings.Settings.instance().moduleSetting<boolean>('request-blocking-enabled');
   readonly #requestConditions = new RequestConditions();
   readonly #urlsForRequestInterceptor:
       Platform.MapUtilities.Multimap<(arg0: InterceptedRequest) => Promise<void>, InterceptionPattern> =
@@ -1844,7 +1951,6 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
       this.updateBlockedPatterns();
       this.dispatchEventToListeners(MultitargetNetworkManager.Events.BLOCKED_PATTERNS_CHANGED);
     };
-    this.#blockingEnabledSetting.addChangeListener(blockedPatternChanged);
     this.#requestConditions.addEventListener(
         RequestConditions.Events.REQUEST_CONDITIONS_CHANGED, blockedPatternChanged);
     this.updateBlockedPatterns();
@@ -1914,7 +2020,8 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
       void networkAgent.invoke_setUserAgentOverride(
           {userAgent: this.currentUserAgent(), userAgentMetadata: this.#userAgentMetadataOverride || undefined});
     }
-    this.#requestConditions.applyConditions(networkAgent);
+    this.#requestConditions.applyConditions(
+        this.isOffline(), this.isThrottling() ? this.#networkConditions : null, networkAgent);
     if (this.isIntercepting()) {
       void fetchAgent.invoke_enable({patterns: this.#urlsForRequestInterceptor.valuesArray()});
     }
@@ -1925,7 +2032,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
     }
     this.#networkAgents.add(networkAgent);
     this.#fetchAgents.add(fetchAgent);
-    if (this.isThrottling()) {
+    if (this.isThrottling() && !Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
       this.updateNetworkConditions(networkAgent);
     }
   }
@@ -1953,8 +2060,13 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
 
   setNetworkConditions(conditions: Conditions): void {
     this.#networkConditions = conditions;
-    for (const agent of this.#networkAgents) {
-      this.updateNetworkConditions(agent);
+    if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+      this.#requestConditions.applyConditions(
+          this.isOffline(), this.isThrottling() ? this.#networkConditions : null, ...this.#networkAgents);
+    } else {
+      for (const agent of this.#networkAgents) {
+        this.updateNetworkConditions(agent);
+      }
     }
     this.dispatchEventToListeners(MultitargetNetworkManager.Events.CONDITIONS_CHANGED);
   }
@@ -2058,12 +2170,16 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
     return this.#requestConditions;
   }
 
-  blockingEnabled(): boolean {
-    return this.#blockingEnabledSetting.get();
+  isBlocking(): boolean {
+    return this.#isBlocking && this.requestConditions.conditionsEnabled;
   }
 
-  isBlocking(): boolean {
-    return this.#isBlocking && this.blockingEnabled();
+  /**
+   * @deprecated Kept for layout tests
+   * TODO(pfaffe) remove
+   */
+  private setBlockingEnabled(enabled: boolean): void {
+    this.requestConditions.conditionsEnabled = enabled;
   }
 
   /**
@@ -2072,18 +2188,12 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
    */
   private setBlockedPatterns(patterns: Array<{url: string, enabled: boolean}>): void {
     this.requestConditions.clear();
-    this.requestConditions.add(...patterns.map(pattern => new RequestCondition(pattern)));
-  }
-
-  setBlockingEnabled(enabled: boolean): void {
-    if (this.#blockingEnabledSetting.get() === enabled) {
-      return;
-    }
-    this.#blockingEnabledSetting.set(enabled);
+    this.requestConditions.add(...patterns.map(pattern => RequestCondition.createFromSetting(pattern)));
   }
 
   private updateBlockedPatterns(): void {
-    this.#isBlocking = this.#requestConditions.applyConditions(...this.#networkAgents);
+    this.#isBlocking = this.#requestConditions.applyConditions(
+        this.isOffline(), this.isThrottling() ? this.#networkConditions : null, ...this.#networkAgents);
   }
 
   isIntercepting(): boolean {
@@ -2544,6 +2654,10 @@ export function getPredefinedCondition(key: ThrottlingConditionKey): Conditions|
   return THROTTLING_CONDITIONS_LOOKUP.get(key) ?? null;
 }
 
+export function getPredefinedOrBlockingCondition(key: ThrottlingConditionKey): ThrottlingConditions|null {
+  return key === PredefinedThrottlingConditionKey.BLOCKING ? BlockingConditions : getPredefinedCondition(key);
+}
+
 export type ThrottlingConditions = Conditions|{
   readonly key: ThrottlingConditionKey,
   block: true,

package/front_end/core/sdk/SourceMap.ts

@@ -12,7 +12,7 @@ import type {CallFrame, ScopeChainEntry} from './DebuggerModel.js';
 import {scopeTreeForScript} from './ScopeTreeCache.js';
 import type {Script} from './Script.js';
 import {buildOriginalScopes, decodePastaRanges, type NamedFunctionRange} from './SourceMapFunctionRanges.js';
-import {SourceMapScopesInfo} from './SourceMapScopesInfo.js';
+import {SourceMapScopesInfo, type TranslatedFrame} from './SourceMapScopesInfo.js';
 
 /**
  * Type of the base source map JSON object, which contains the sources and the mappings at the very least, plus
@@ -789,6 +789,11 @@ export class SourceMap {
     this.#ensureSourceMapProcessed();
     return this.#scopesInfo?.hasInlinedFrames(generatedLine, generatedColumn) ?? false;
   }
+
+  translateCallSite(generatedLine: number, generatedColumn: number): TranslatedFrame[] {
+    this.#ensureSourceMapProcessed();
+    return this.#scopesInfo?.translateCallSite(generatedLine, generatedColumn) ?? [];
+  }
 }
 
 const VLQ_BASE_SHIFT = 5;

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -113,6 +113,10 @@ export class SourceMapScopesInfo {
    */
   isOutlinedFrame(generatedLine: number, generatedColumn: number): boolean {
     const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    return this.#isOutlinedFrame(rangeChain);
+  }
+
+  #isOutlinedFrame(rangeChain: ScopesCodec.GeneratedRange[]): boolean {
     for (let i = rangeChain.length - 1; i >= 0; --i) {
       if (rangeChain[i].isStackFrame) {
         return rangeChain[i].isHidden;
@@ -372,13 +376,7 @@ export class SourceMapScopesInfo {
               .at(-1);
     }
 
-    // Walk the original scope chain outwards until we find a function.
-    for (let originalScope = originalInnerMostScope; originalScope; originalScope = originalScope.parent) {
-      if (originalScope.isStackFrame) {
-        return originalScope.name ?? '';
-      }
-    }
-    return null;
+    return this.#findFunctionNameInOriginalScopeChain(originalInnerMostScope) ?? null;
   }
 
   /**
@@ -404,6 +402,74 @@ export class SourceMapScopesInfo {
 
     return result;
   }
+
+  #findFunctionNameInOriginalScopeChain(innerOriginalScope: ScopesCodec.OriginalScope|undefined): string|null {
+    for (let originalScope = innerOriginalScope; originalScope; originalScope = originalScope.parent) {
+      if (originalScope.isStackFrame) {
+        return originalScope.name ?? '';
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Returns one or more original stack frames for this single "raw frame" or call-site.
+   *
+   * @returns An empty array if no mapping at the call-site was found, or the resulting frames
+   * in top-to-bottom order in case of inlining.
+   * @throws If this range is marked "hidden". Outlining needs to be handled externally as
+   * outlined function segments in stack traces can span across bundles.
+   */
+  translateCallSite(generatedLine: number, generatedColumn: number): TranslatedFrame[] {
+    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    if (this.#isOutlinedFrame(rangeChain)) {
+      throw new Error('SourceMapScopesInfo is unable to translate an outlined function by itself');
+    }
+
+    const mapping = this.#sourceMap.findEntry(generatedLine, generatedColumn);
+    if (mapping?.sourceIndex === undefined) {
+      return [];
+    }
+
+    // The top-most frame is translated the same even if we have inlined functions.
+    const result: TranslatedFrame[] = [{
+      line: mapping.sourceLineNumber,
+      column: mapping.sourceColumnNumber,
+      name: this.findOriginalFunctionName({line: generatedLine, column: generatedColumn}) ?? undefined,
+      url: mapping.sourceURL,
+    }];
+
+    // Walk the range chain inside out until we find a generated function and for each inlined function add a frame.
+    for (let i = rangeChain.length - 1; i >= 0 && !rangeChain[i].isStackFrame; --i) {
+      const range = rangeChain[i];
+      if (!range.callSite) {
+        continue;
+      }
+
+      const originalScopeChain = this.#findOriginalScopeChain(range.callSite);
+      result.push({
+        line: range.callSite.line,
+        column: range.callSite.column,
+        name: this.#findFunctionNameInOriginalScopeChain(originalScopeChain.at(-1)) ?? undefined,
+        url: this.#sourceMap.sourceURLForSourceIndex(range.callSite.sourceIndex),
+      });
+    }
+
+    return result;
+  }
+}
+
+/**
+ * Represents a stack frame in original terms. It closely aligns with StackTrace.StackTrace.Frame,
+ * but since we can't import that type here we mirror it here somewhat.
+ *
+ * Equivalent to Pick<StackTrace.StackTrace.Frame, 'line'|'column'|'name'|'url'>.
+ */
+export interface TranslatedFrame {
+  line: number;
+  column: number;
+  name?: string;
+  url?: Platform.DevToolsPath.UrlString;
 }
 
 /**

package/front_end/models/ai_assistance/data_formatters/PerformanceTraceFormatterBounds.snapshot.txt

@@ -0,0 +1,4 @@
+Title: PerformanceTraceFormatter serializeBounds works
+Content:
+{min: 1, max: 2}
+=== end content

package/front_end/models/bindings/CompilerScriptMapping.ts

@@ -296,28 +296,30 @@ export class CompilerScriptMapping implements DebuggerSourceMapping {
     const {sourceMap, script} = sourceMapAndScript;
     const {lineNumber, columnNumber} = script.relativeLocationToRawLocation(frame);
 
-    if (!sourceMap.hasInlinedFrames(lineNumber, columnNumber) && !sourceMap.isOutlinedFrame(lineNumber, columnNumber)) {
-      // No outlining or inlining: Get the original function name and map the call-site.
-      const mapping = sourceMap.findEntry(lineNumber, columnNumber);
-      if (!mapping?.sourceURL) {
+    if (!sourceMap.isOutlinedFrame(lineNumber, columnNumber)) {
+      const frames = sourceMap.translateCallSite(lineNumber, columnNumber);
+      if (!frames.length) {
         return false;
       }
 
-      const originalName = sourceMap.findOriginalFunctionName({line: lineNumber, column: columnNumber});
       rawFrames.shift();
+      const result: typeof translatedFrames[0] = [];
+      translatedFrames.push(result);
+
       const project = this.#sourceMapToProject.get(sourceMap);
-      const uiSourceCode = project?.uiSourceCodeForURL(mapping.sourceURL);
-      translatedFrames.push([{
-        line: mapping.sourceLineNumber,
-        column: mapping.sourceColumnNumber,
-        name: originalName ?? undefined,
-        uiSourceCode: uiSourceCode ?? undefined,
-        url: uiSourceCode ? undefined : mapping.sourceURL
-      }]);
+      for (const frame of frames) {
+        // Switch out url for UISourceCode where we have it.
+        const uiSourceCode = frame.url ? project?.uiSourceCodeForURL(frame.url) : undefined;
+        result.push({
+          ...frame,
+          url: uiSourceCode ? undefined : frame.url,
+          uiSourceCode: uiSourceCode ?? undefined,
+        });
+      }
+
       return true;
     }
 
-    // TODO(crbug.com/433162438): Expand inlined frames.
     // TODO(crbug.com/433162438): Consolidate outlined frames.
     return false;
   }

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -6041,7 +6041,13 @@ export const NativeFunctions = [
   },
   {
     name: "waitUntil",
-    signatures: [["f"]]
+    signatures: [["f"]],
+    receivers: ["ExtendableEvent"]
+  },
+  {
+    name: "waitUntil",
+    signatures: [["promise"]],
+    receivers: ["ViewTransition"]
   },
   {
     name: "respondWith",

package/front_end/panels/ai_assistance/AiAssistancePanel.ts

@@ -1187,7 +1187,7 @@ export class AiAssistancePanel extends UI.Panel.Panel {
 
       contextMenu.defaultSection().appendCheckboxItem(title, () => {
         void this.#openHistoricConversation(conversation);
-      }, {checked: (this.#conversation === conversation)});
+      }, {checked: (this.#conversation === conversation), jslogContext: 'freestyler.history-item'});
     }
 
     const historyEmpty = contextMenu.defaultSection().items.length === 0;

package/front_end/panels/console/ConsoleInsightTeaser.ts

@@ -61,6 +61,10 @@ const UIStringsNotTranslate = {
    * @description Header text during loading state while an AI summary is being generated
    */
   summarizing: 'Summarizing…',
+  /**
+   * @description Header text during longer lasting loading state while an AI summary is being generated
+   */
+  summarizingTakesABitLonger: 'Summarizing takes a bit longer…',
   /**
    * @description Label for an animation shown while an AI response is being generated
    */
@@ -77,6 +81,10 @@ const UIStringsNotTranslate = {
    * @description Aria-label for an infor-button triggering a tooltip with more info about data usage
    */
   learnDataUsage: 'Learn more about how your data is used',
+  /**
+   * @description Header text if there was an error during AI summary generation
+   */
+  summaryNotAvailable: 'Summary not available',
 } as const;
 
 const lockedString = i18n.i18n.lockedString;
@@ -84,6 +92,7 @@ const lockedString = i18n.i18n.lockedString;
 const CODE_SNIPPET_WARNING_URL = 'https://support.google.com/legal/answer/13505487';
 const DATA_USAGE_URL = 'https://developer.chrome.com/docs/devtools/ai-assistance/get-started#data-use';
 const EXPLAIN_TEASER_ACTION_ID = 'explain.console-message.teaser';
+const SLOW_GENERATION_CUTOFF_MILLISECONDS = 3500;
 
 interface ViewInput {
   onTellMeMoreClick: (event: Event) => void;
@@ -95,6 +104,8 @@ interface ViewInput {
   isInactive: boolean;
   dontShowChanged: (e: Event) => void;
   hasTellMeMoreButton: boolean;
+  isSlowGeneration: boolean;
+  isError: boolean;
 }
 
 export const DEFAULT_VIEW = (input: ViewInput, _output: undefined, target: HTMLElement): void => {
@@ -104,6 +115,51 @@ export const DEFAULT_VIEW = (input: ViewInput, _output: undefined, target: HTMLE
   }
 
   const showPlaceholder = !Boolean(input.mainText);
+  const renderFooter = (): Lit.LitTemplate => {
+    // clang-format off
+    return html`
+      <div class="tooltip-footer">
+        ${input.hasTellMeMoreButton ? html`
+          <devtools-button
+            title=${lockedString(UIStringsNotTranslate.tellMeMore)}
+            .jslogContext=${'insights-teaser-tell-me-more'},
+            .variant=${Buttons.Button.Variant.PRIMARY}
+            @click=${input.onTellMeMoreClick}
+          >
+            <devtools-icon class="lightbulb-icon" name="lightbulb-spark"></devtools-icon>
+            ${lockedString(UIStringsNotTranslate.tellMeMore)}
+          </devtools-button>
+        ` : Lit.nothing}
+        ${showPlaceholder ? Lit.nothing : html`
+          <devtools-button
+            .iconName=${'info'}
+            .variant=${Buttons.Button.Variant.ICON}
+            aria-details=${'teaser-info-tooltip-' + input.uuid}
+            aria-label=${lockedString(UIStringsNotTranslate.learnDataUsage)}
+          ></devtools-button>
+          <devtools-tooltip id=${'teaser-info-tooltip-' + input.uuid} variant="rich">
+            <div class="info-tooltip-text">${lockedString(UIStringsNotTranslate.infoTooltipText)}</div>
+            <div class="learn-more">
+              <x-link
+                class="devtools-link"
+                title=${lockedString(UIStringsNotTranslate.learnMoreAboutAiSummaries)}
+                href=${DATA_USAGE_URL}
+                jslog=${VisualLogging.link().track({click: true, keydown:'Enter|Space'}).context('explain.teaser.learn-more')}
+              >${lockedString(UIStringsNotTranslate.learnMoreAboutAiSummaries)}</x-link>
+            </div>
+          </devtools-tooltip>
+        `}
+        <devtools-checkbox
+          aria-label=${lockedString(UIStringsNotTranslate.dontShow)}
+          @change=${input.dontShowChanged}
+          jslog=${VisualLogging.toggle('explain.teaser.dont-show').track({ change: true })}>
+          ${lockedString(UIStringsNotTranslate.dontShow)}
+        </devtools-checkbox>
+      </div>
+    `;
+    // clang-format on
+  };
+
   // clang-format off
   render(html`
     <style>${consoleInsightTeaserStyles}</style>
@@ -115,64 +171,36 @@ export const DEFAULT_VIEW = (input: ViewInput, _output: undefined, target: HTMLE
       prefer-span-left
     >
       <div class="teaser-tooltip-container">
-        ${showPlaceholder ? html`
-          <h2>${lockedString(UIStringsNotTranslate.summarizing)}</h2>
-          <div
-            role="presentation"
-            aria-label=${lockedString(UIStringsNotTranslate.loading)}
-            class="loader"
-            style="clip-path: url(${'#clipPath-' + input.uuid});"
-          >
-            <svg width="100%" height="52">
-              <defs>
-              <clipPath id=${'clipPath-' + input.uuid}>
-                <rect x="0" y="0" width="100%" height="12" rx="8"></rect>
-                <rect x="0" y="20" width="100%" height="12" rx="8"></rect>
-                <rect x="0" y="40" width="100%" height="12" rx="8"></rect>
-              </clipPath>
-            </defs>
-            </svg>
-          </div>
-        ` : html`
-          <h2>${input.headerText}</h2>
-          <div>${input.mainText}</div>
-          <div class="tooltip-footer">
-            ${input.hasTellMeMoreButton ? html`
-              <devtools-button
-                title=${lockedString(UIStringsNotTranslate.tellMeMore)}
-                .jslogContext=${'insights-teaser-tell-me-more'},
-                .variant=${Buttons.Button.Variant.PRIMARY}
-                @click=${input.onTellMeMoreClick}
-              >
-                <devtools-icon class="lightbulb-icon" name="lightbulb-spark"></devtools-icon>
-                ${lockedString(UIStringsNotTranslate.tellMeMore)}
-              </devtools-button>
-            ` : Lit.nothing}
-            <devtools-button
-              .iconName=${'info'}
-              .variant=${Buttons.Button.Variant.ICON}
-              aria-details=${'teaser-info-tooltip-' + input.uuid}
-              aria-label=${lockedString(UIStringsNotTranslate.learnDataUsage)}
-            ></devtools-button>
-            <devtools-tooltip id=${'teaser-info-tooltip-' + input.uuid} variant="rich">
-              <div class="info-tooltip-text">${lockedString(UIStringsNotTranslate.infoTooltipText)}</div>
-              <div class="learn-more">
-                <x-link
-                  class="devtools-link"
-                  title=${lockedString(UIStringsNotTranslate.learnMoreAboutAiSummaries)}
-                  href=${DATA_USAGE_URL}
-                  jslog=${VisualLogging.link().track({click: true, keydown:'Enter|Space'}).context('explain.teaser.learn-more')}
-                >${lockedString(UIStringsNotTranslate.learnMoreAboutAiSummaries)}</x-link>
-              </div>
-            </devtools-tooltip>
-            <devtools-checkbox
-              aria-label=${lockedString(UIStringsNotTranslate.dontShow)}
-              @change=${input.dontShowChanged}
-              jslog=${VisualLogging.toggle('explain.teaser.dont-show').track({ change: true })}>
-              ${lockedString(UIStringsNotTranslate.dontShow)}
-            </devtools-checkbox>
-          </div>
-        `}
+        ${input.isError ? html`
+          <h2>${lockedString(UIStringsNotTranslate.summaryNotAvailable)}</h2>
+        ` :
+          showPlaceholder ? html`
+            <h2>${input.isSlowGeneration ?
+              lockedString(UIStringsNotTranslate.summarizingTakesABitLonger) :
+              lockedString(UIStringsNotTranslate.summarizing)
+            }</h2>
+            <div
+              role="presentation"
+              aria-label=${lockedString(UIStringsNotTranslate.loading)}
+              class="loader"
+              style="clip-path: url(${'#clipPath-' + input.uuid});"
+            >
+              <svg width="100%" height="52">
+                <defs>
+                <clipPath id=${'clipPath-' + input.uuid}>
+                  <rect x="0" y="0" width="100%" height="12" rx="8"></rect>
+                  <rect x="0" y="20" width="100%" height="12" rx="8"></rect>
+                  <rect x="0" y="40" width="100%" height="12" rx="8"></rect>
+                </clipPath>
+              </defs>
+              </svg>
+            </div>
+          ` : html`
+            <h2>${input.headerText}</h2>
+            <div>${input.mainText}</div>
+          `
+        }
+        ${input.isError || input.isSlowGeneration || !showPlaceholder ? renderFooter() : Lit.nothing}
       </div>
     </devtools-tooltip>
   `, target);
@@ -192,6 +220,9 @@ export class ConsoleInsightTeaser extends UI.Widget.Widget {
   #consoleViewMessage: ConsoleViewMessage;
   #isInactive = false;
   #abortController: null|AbortController = null;
+  #isSlow = false;
+  #timeoutId: ReturnType<typeof setTimeout>|null = null;
+  #isError = false;
 
   constructor(uuid: string, consoleViewMessage: ConsoleViewMessage, element?: HTMLElement, view?: View) {
     super(element);
@@ -285,6 +316,9 @@ export class ConsoleInsightTeaser extends UI.Widget.Widget {
       this.#abortController.abort();
     }
     this.#isGenerating = false;
+    if (this.#timeoutId) {
+      clearTimeout(this.#timeoutId);
+    }
   }
 
   setInactive(isInactive: boolean): void {
@@ -295,8 +329,14 @@ export class ConsoleInsightTeaser extends UI.Widget.Widget {
     this.requestUpdate();
   }
 
+  #setSlow(): void {
+    this.#isSlow = true;
+    this.requestUpdate();
+  }
+
   async #generateTeaserText(): Promise<void> {
     this.#isGenerating = true;
+    this.#timeoutId = setTimeout(this.#setSlow.bind(this), SLOW_GENERATION_CUTOFF_MILLISECONDS);
     let teaserText = '';
     try {
       for await (const chunk of this.#getOnDeviceInsight()) {
@@ -306,12 +346,16 @@ export class ConsoleInsightTeaser extends UI.Widget.Widget {
       // Ignore `AbortError` errors, which are thrown on mouse leave.
       if (err.name !== 'AbortError') {
         console.error(err.name, err.message);
+        this.#isError = true;
       }
       this.#isGenerating = false;
+      clearTimeout(this.#timeoutId);
+      this.requestUpdate();
       return;
     }
 
-    // TODO(crbug.com/443618746): Add user-facing error message instead of staying in loading state
+    clearTimeout(this.#timeoutId);
+    this.#isGenerating = false;
     let responseObject = {
       header: null,
       explanation: null,
@@ -320,10 +364,15 @@ export class ConsoleInsightTeaser extends UI.Widget.Widget {
       responseObject = JSON.parse(teaserText);
     } catch (err) {
       console.error(err.name, err.message);
+      this.#isError = true;
+      this.requestUpdate();
+      return;
     }
     this.#headerText = responseObject.header || '';
     this.#mainText = responseObject.explanation || '';
-    this.#isGenerating = false;
+    if (!this.#headerText || !this.#mainText) {
+      this.#isError = true;
+    }
     this.requestUpdate();
   }
 
@@ -373,6 +422,8 @@ export class ConsoleInsightTeaser extends UI.Widget.Widget {
               !Common.Settings.Settings.instance().moduleSetting('console-insight-teasers-enabled').get(),
           dontShowChanged: this.#dontShowChanged.bind(this),
           hasTellMeMoreButton: this.#hasTellMeMoreButton(),
+          isSlowGeneration: this.#isSlow,
+          isError: this.#isError,
         },
         undefined, this.contentElement);
   }

package/front_end/panels/console/ConsoleSidebar.ts

@@ -52,7 +52,7 @@ const str_ = i18n.i18n.registerUIStrings('panels/console/ConsoleSidebar.ts', UIS
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 const {render, html, nothing, Directives} = Lit;
 
-const enum GroupName {
+export const enum GroupName {
   CONSOLE_API = 'user message',
   ALL = 'message',
   ERROR = 'error',
@@ -112,7 +112,7 @@ export const DEFAULT_VIEW: View = (input, output, target) => {
                   <ul role="group" hidden>
                     ${group.urlGroups.values().map(urlGroup => html`
                       <li
-                        ${Directives.ref(element => element && nodeFilterMap.set(element, group.filter))}
+                        ${Directives.ref(element => element && nodeFilterMap.set(element, urlGroup.filter))}
                         role="treeitem"
                         ?selected=${urlGroup.filter === input.selectedFilter}
                         title=${urlGroup.url ?? ''}>
@@ -126,7 +126,7 @@ export const DEFAULT_VIEW: View = (input, output, target) => {
       target);
 };
 
-class ConsoleFilterGroup {
+export class ConsoleFilterGroup {
   readonly urlGroups = new Map<string|null, {filter: ConsoleFilter, url: string|null, count: number}>();
   messageCount = 0;
   readonly name: GroupName;

package/front_end/panels/network/BlockedURLsPane.ts

@@ -17,6 +17,7 @@ import * as Buttons from '../../ui/components/buttons/buttons.js';
 import * as UI from '../../ui/legacy/legacy.js';
 import {Directives, html, type LitTemplate, nothing, render} from '../../ui/lit/lit.js';
 import * as VisualLogging from '../../ui/visual_logging/visual_logging.js';
+import * as MobileThrottling from '../mobile_throttling/mobile_throttling.js';
 
 import blockedURLsPaneStyles from './blockedURLsPane.css.js';
 
@@ -192,7 +193,7 @@ export class BlockedURLsPane extends UI.Widget.VBox implements
   }
 
   override performUpdate(): void {
-    const enabled = this.manager.blockingEnabled();
+    const enabled = this.manager.requestConditions.conditionsEnabled;
     this.list.element.classList.toggle('blocking-disabled', !enabled && Boolean(this.manager.requestConditions.count));
 
     const input: ViewInput = {
@@ -205,9 +206,11 @@ export class BlockedURLsPane extends UI.Widget.VBox implements
   }
 
   addPattern(): void {
-    this.manager.setBlockingEnabled(true);
+    this.manager.requestConditions.conditionsEnabled = true;
     this.list.addNewItem(
-        0, new SDK.NetworkManager.RequestCondition({url: Platform.DevToolsPath.EmptyUrlString, enabled: true}));
+        0,
+        SDK.NetworkManager.RequestCondition.createFromSetting(
+            {url: Platform.DevToolsPath.EmptyUrlString, enabled: true}));
   }
 
   removeAllPatterns(): void {
@@ -224,6 +227,11 @@ export class BlockedURLsPane extends UI.Widget.VBox implements
         condition.enabled = !condition.enabled;
       }
     };
+    const onConditionsChanged = (conditions: SDK.NetworkManager.ThrottlingConditions): void => {
+      if (editable) {
+        condition.conditions = conditions;
+      }
+    };
 
     const {enabled, originalOrUpgradedURLPattern, constructorStringOrWildcardURL, wildcardURL} = condition;
 
@@ -237,6 +245,17 @@ export class BlockedURLsPane extends UI.Widget.VBox implements
       ?checked=${enabled}
       ?disabled=${!editable || !originalOrUpgradedURLPattern}
       .jslog=${VisualLogging.toggle().track({ change: true })}>
+    <devtools-widget
+      class=conditions-selector
+      ?disabled=${!editable}
+      .widgetConfig=${UI.Widget.widgetConfig(
+        MobileThrottling.NetworkThrottlingSelector.NetworkThrottlingSelectorWidget, {
+          variant:
+            MobileThrottling.NetworkThrottlingSelector.NetworkThrottlingSelect.Variant.INDIVIDUAL_REQUEST_CONDITIONS,
+          jslogContext: 'request-conditions',
+          onConditionsChanged,
+          currentConditions: condition.conditions,
+        })}></devtools-widget>
     ${originalOrUpgradedURLPattern ? html`
       <devtools-tooltip variant=rich jslogcontext=url-pattern id=url-pattern-${index}>
         <div>hash: ${originalOrUpgradedURLPattern.hash}</div>
@@ -267,7 +286,12 @@ export class BlockedURLsPane extends UI.Widget.VBox implements
             : i18nString(UIStrings.patternFailedToParse)}
         ${learnMore()}
       </devtools-tooltip>`: nothing}
-    <div @click=${toggle} class=blocked-url-label aria-details=url-pattern-${index}>${constructorStringOrWildcardURL}</div>
+    <div
+      @click=${toggle}
+      class=blocked-url-label
+      aria-details=url-pattern-${index}>
+        ${constructorStringOrWildcardURL}
+    </div>
     <div class=blocked-url-count>${i18nString(UIStrings.dBlocked, {PH1: count})}</div>`,
           // clang-format on
           element);
@@ -290,7 +314,7 @@ export class BlockedURLsPane extends UI.Widget.VBox implements
   }
 
   private toggleEnabled(): void {
-    this.manager.setBlockingEnabled(!this.manager.blockingEnabled());
+    this.manager.requestConditions.conditionsEnabled = !this.manager.requestConditions.conditionsEnabled;
     this.update();
   }
 
@@ -368,7 +392,7 @@ export class BlockedURLsPane extends UI.Widget.VBox implements
   }
 
   update(): void {
-    const enabled = this.manager.blockingEnabled();
+    const enabled = this.manager.requestConditions.conditionsEnabled;
     this.list.clear();
     for (const pattern of this.manager.requestConditions.conditions) {
       if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled || pattern.wildcardURL) {

package/front_end/panels/network/NetworkLogView.ts

@@ -432,6 +432,27 @@ const UIStrings = {
    * @description A context menu item in the Network Log View of the Network panel
    */
   clearBrowserCookies: 'Clear browser cookies',
+  /**
+   * @description A context menu item in the Network Log View of the Network panel
+   */
+  throttleRequests: 'Throttle requests',
+  /**
+   * @description A context menu item in the Network Log View of the Network panel
+   */
+  throttleRequestUrl: 'Throttle request URL',
+  /**
+   * @description A context menu item in the Network Log View of the Network panel
+   * @example {example.com} PH1
+   */
+  unthrottleS: 'Stop throttling {PH1}',
+  /**
+   * @description A context menu item in the Network Log View of the Network panel
+   */
+  throttleRequestDomain: 'Throttle request domain',
+  /**
+   * @description A context menu item in the Network Log View of the Network panel
+   */
+  blockRequests: 'Block requests',
   /**
    * @description A context menu item in the Network Log View of the Network panel
    */
@@ -1849,43 +1870,124 @@ export class NetworkLogView extends Common.ObjectWrapper.eventMixin<EventTypes,
       const maxBlockedURLLength = 20;
       const manager = SDK.NetworkManager.MultitargetNetworkManager.instance();
 
-      function addBlockedURL(url: string): void {
-        manager.requestConditions.add(
-            new SDK.NetworkManager.RequestCondition({enabled: true, url: url as Platform.DevToolsPath.UrlString}));
-        manager.setBlockingEnabled(true);
-        void UI.ViewManager.ViewManager.instance().showView('network.blocked-urls');
-      }
+      if (!Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+        function addBlockedURL(url: string): void {
+          manager.requestConditions.add(SDK.NetworkManager.RequestCondition.createFromSetting(
+              {enabled: true, url: url as Platform.DevToolsPath.UrlString}));
+          manager.requestConditions.conditionsEnabled = true;
+          void UI.ViewManager.ViewManager.instance().showView('network.blocked-urls');
+        }
 
-      function removeBlockedURL(url: string): void {
-        const entry = manager.requestConditions.findCondition(url);
-        if (entry) {
-          manager.requestConditions.delete(entry);
+        function removeBlockedURL(url: string): void {
+          const entry = manager.requestConditions.findCondition(url);
+          if (entry) {
+            manager.requestConditions.delete(entry);
+          }
+          void UI.ViewManager.ViewManager.instance().showView('network.blocked-urls');
         }
-        void UI.ViewManager.ViewManager.instance().showView('network.blocked-urls');
-      }
 
-      const urlWithoutScheme = request.parsedURL.urlWithoutScheme();
-      if (urlWithoutScheme && !manager.requestConditions.has(urlWithoutScheme)) {
-        contextMenu.debugSection().appendItem(
-            i18nString(UIStrings.blockRequestUrl), addBlockedURL.bind(null, urlWithoutScheme),
-            {jslogContext: 'block-request-url'});
-      } else if (urlWithoutScheme) {
-        const croppedURL = Platform.StringUtilities.trimMiddle(urlWithoutScheme, maxBlockedURLLength);
-        contextMenu.debugSection().appendItem(
-            i18nString(UIStrings.unblockS, {PH1: croppedURL}), removeBlockedURL.bind(null, urlWithoutScheme),
-            {jslogContext: 'unblock'});
-      }
+        const urlWithoutScheme = request.parsedURL.urlWithoutScheme();
+        if (urlWithoutScheme && !manager.requestConditions.has(urlWithoutScheme)) {
+          contextMenu.debugSection().appendItem(
+              i18nString(UIStrings.blockRequestUrl), addBlockedURL.bind(null, urlWithoutScheme),
+              {jslogContext: 'block-request-url'});
+        } else if (urlWithoutScheme) {
+          const croppedURL = Platform.StringUtilities.trimMiddle(urlWithoutScheme, maxBlockedURLLength);
+          contextMenu.debugSection().appendItem(
+              i18nString(UIStrings.unblockS, {PH1: croppedURL}), removeBlockedURL.bind(null, urlWithoutScheme),
+              {jslogContext: 'unblock'});
+        }
 
-      const domain = request.parsedURL.domain();
-      if (domain && !manager.requestConditions.has(domain)) {
-        contextMenu.debugSection().appendItem(
-            i18nString(UIStrings.blockRequestDomain), addBlockedURL.bind(null, domain),
-            {jslogContext: 'block-request-domain'});
-      } else if (domain) {
-        const croppedDomain = Platform.StringUtilities.trimMiddle(domain, maxBlockedURLLength);
-        contextMenu.debugSection().appendItem(
-            i18nString(UIStrings.unblockS, {PH1: croppedDomain}), removeBlockedURL.bind(null, domain),
-            {jslogContext: 'unblock'});
+        const domain = request.parsedURL.domain();
+        if (domain && !manager.requestConditions.has(domain)) {
+          contextMenu.debugSection().appendItem(
+              i18nString(UIStrings.blockRequestDomain), addBlockedURL.bind(null, domain),
+              {jslogContext: 'block-request-domain'});
+        } else if (domain) {
+          const croppedDomain = Platform.StringUtilities.trimMiddle(domain, maxBlockedURLLength);
+          contextMenu.debugSection().appendItem(
+              i18nString(UIStrings.unblockS, {PH1: croppedDomain}), removeBlockedURL.bind(null, domain),
+              {jslogContext: 'unblock'});
+        }
+      } else {
+        function removeRequestCondition(pattern: SDK.NetworkManager.RequestURLPattern): void {
+          const entry = manager.requestConditions.findCondition(pattern.constructorString);
+          if (entry) {
+            manager.requestConditions.delete(entry);
+            void UI.ViewManager.ViewManager.instance().showView('network.blocked-urls');
+          }
+        }
+
+        function addRequestCondition(
+            pattern: SDK.NetworkManager.RequestURLPattern,
+            conditions: SDK.NetworkManager.ThrottlingConditions,
+            ): void {
+          const entry = manager.requestConditions.findCondition(pattern.constructorString);
+          if (entry) {
+            entry.conditions = conditions;
+          } else {
+            manager.requestConditions.add(SDK.NetworkManager.RequestCondition.create(pattern, conditions));
+          }
+          manager.requestConditions.conditionsEnabled = true;
+          void UI.ViewManager.ViewManager.instance().showView('network.blocked-urls');
+        }
+
+        const blockingMenu =
+            contextMenu.debugSection().appendSubMenuItem(i18nString(UIStrings.blockRequests), /* disabled=*/ true);
+        const throttlingMenu =
+            contextMenu.debugSection().appendSubMenuItem(i18nString(UIStrings.throttleRequests), /* disabled=*/ true);
+
+        const urlWithoutScheme = request.parsedURL.urlWithoutScheme();
+        const urlPattern = urlWithoutScheme &&
+            SDK.NetworkManager.RequestURLPattern.create(
+                `*://${urlWithoutScheme}` as SDK.NetworkManager.URLPatternConstructorString);
+        if (urlPattern) {
+          throttlingMenu.setEnabled(true);
+          blockingMenu.setEnabled(true);
+          const existingConditions = manager.requestConditions.findCondition(urlPattern.constructorString);
+          const isBlocking = existingConditions?.conditions === SDK.NetworkManager.BlockingConditions;
+          const isThrottling = existingConditions &&
+              existingConditions.conditions !== SDK.NetworkManager.BlockingConditions &&
+              existingConditions.conditions !== SDK.NetworkManager.NoThrottlingConditions;
+          blockingMenu.debugSection().appendItem(
+              isBlocking ? i18nString(UIStrings.unblockS, {PH1: urlPattern.constructorString}) :
+                           i18nString(UIStrings.blockRequestUrl),
+              () => isBlocking ? removeRequestCondition(urlPattern) :
+                                 addRequestCondition(urlPattern, SDK.NetworkManager.BlockingConditions),
+              {jslogContext: 'block-request-url'});
+          throttlingMenu.debugSection().appendItem(
+              isThrottling ? i18nString(UIStrings.unthrottleS, {PH1: urlPattern.constructorString}) :
+                             i18nString(UIStrings.throttleRequestUrl),
+              () => isThrottling ? removeRequestCondition(urlPattern) :
+                                   addRequestCondition(urlPattern, SDK.NetworkManager.Slow3GConditions),
+              {jslogContext: 'throttle-request-url'});
+        }
+
+        const domain = request.parsedURL.domain();
+        const domainPattern = domain &&
+            SDK.NetworkManager.RequestURLPattern.create(
+                `*://${domain}` as SDK.NetworkManager.URLPatternConstructorString);
+        if (domainPattern) {
+          throttlingMenu.setEnabled(true);
+          blockingMenu.setEnabled(true);
+          const existingConditions = manager.requestConditions.findCondition(domainPattern.constructorString);
+          const isBlocking = existingConditions?.conditions === SDK.NetworkManager.BlockingConditions;
+          const isThrottling = existingConditions &&
+              existingConditions.conditions !== SDK.NetworkManager.BlockingConditions &&
+              existingConditions.conditions !== SDK.NetworkManager.NoThrottlingConditions;
+          blockingMenu.debugSection().appendItem(
+              isBlocking ? i18nString(UIStrings.unblockS, {PH1: domainPattern.constructorString}) :
+                           i18nString(UIStrings.blockRequestDomain),
+              () => isBlocking ? removeRequestCondition(domainPattern) :
+                                 addRequestCondition(domainPattern, SDK.NetworkManager.BlockingConditions),
+              {jslogContext: 'block-request-domain'});
+          throttlingMenu.debugSection().appendItem(
+              isThrottling ? i18nString(UIStrings.unthrottleS, {PH1: domainPattern.constructorString}) :
+                             i18nString(UIStrings.throttleRequestDomain),
+              () => isThrottling ? removeRequestCondition(domainPattern) :
+                                   addRequestCondition(domainPattern, SDK.NetworkManager.Slow3GConditions),
+              {jslogContext: 'throttle-request-domain'});
+        }
       }
 
       if (SDK.NetworkManager.NetworkManager.canReplayRequest(request)) {

package/front_end/panels/network/blockedURLsPane.css

@@ -74,3 +74,8 @@
   text-align: inherit;
   height: 22px;
 }
+
+.conditions-selector {
+  max-width: 120px;
+  margin: var(--sys-size-3);
+}

package/front_end/panels/sources/sources-meta.ts

@@ -516,6 +516,7 @@ UI.ViewManager.registerViewExtension({
   title: i18nLazyString(UIStrings.workspace),
   order: 3,
   persistence: UI.ViewManager.ViewPersistence.PERMANENT,
+  condition: () => !Root.Runtime.Runtime.isTraceApp(),
   async loadView() {
     const Sources = await loadSourcesModule();
     return new Sources.SourcesNavigator.FilesNavigatorView();

package/front_end/third_party/chromium/README.chromium

@@ -1,7 +1,7 @@
 Name: Dependencies sourced from the upstream `chromium` repository
 URL: https://source.chromium.org/chromium/chromium/src/+/main:components/variations/proto/devtools/
 Version: N/A
-Revision: b8cee13d6f07e8bccc83905ddeccf1865b86b5e4
+Revision: 8e79193039bf1dd9a37c1b3c443dd8159e02c194
 Update Mechanism: Manual (https://crbug.com/428069060)
 License: BSD-3-Clause
 License File: LICENSE

package/front_end/ui/visual_logging/KnownContextValues.ts

@@ -575,6 +575,7 @@ export const knownContextValues = new Set([
   'black-berry-play-book-2.1',
   'blackbox',
   'ble',
+  'block',
   'block-ellipsis',
   'block-request-domain',
   'block-request-url',
@@ -1688,6 +1689,7 @@ export const knownContextValues = new Set([
   'freestyler.feedback',
   'freestyler.help',
   'freestyler.history',
+  'freestyler.history-item',
   'freestyler.main-menu',
   'freestyler.new-chat',
   'freestyler.send-feedback',
@@ -3082,6 +3084,7 @@ export const knownContextValues = new Set([
   'request-animation-frame.callback',
   'request-blocking-enabled',
   'request-blocking-enabled-true',
+  'request-conditions',
   'request-details',
   'request-header',
   'request-header-accept',
@@ -3745,6 +3748,8 @@ export const knownContextValues = new Set([
   'third-party-tree',
   'third-property',
   'this-origin',
+  'throttle-request-domain',
+  'throttle-request-url',
   'throttling-conditions',
   'throttling.calibrate',
   'throttling.calibrate-cancel',

package/package.json

@@ -102,5 +102,5 @@
       "flat-cache": "6.1.12"
     }
   },
-  "version": "1.0.1530564"
+  "version": "1.0.1531367"
 }