chrome-devtools-mcp-for-extension 0.19.2 → 0.20.0

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/NetworkManager.js

@@ -1,14 +1,14 @@
 // Copyright 2011 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+var _a;
 import * as TextUtils from '../../models/text_utils/text_utils.js';
 import * as Common from '../common/common.js';
-import * as Host from '../host/host.js';
 import * as i18n from '../i18n/i18n.js';
 import * as Platform from '../platform/platform.js';
 import * as Root from '../root/root.js';
 import { Cookie } from './Cookie.js';
-import { DirectSocketChunkType, DirectSocketStatus, DirectSocketType, Events as NetworkRequestEvents, NetworkRequest } from './NetworkRequest.js';
+import { DirectSocketChunkType, DirectSocketStatus, DirectSocketType, Events as NetworkRequestEvents, NetworkRequest, } from './NetworkRequest.js';
 import { SDKModel } from './SDKModel.js';
 import { TargetManager } from './TargetManager.js';
 const UIStrings = {
@@ -50,6 +50,10 @@ const UIStrings = {
      * @description Text in Network Manager representing the "Fast 4G" throttling preset
      */
     fast4G: 'Fast 4G',
+    /**
+     * @description Text in Network Manager representing the "Blocking" throttling preset
+     */
+    block: 'Block',
     /**
      * @description Text in Network Manager
      * @example {https://example.com} PH1
@@ -137,6 +141,8 @@ export class NetworkManager extends SDKModel {
         }
         void this.#networkAgent.invoke_enable({
             maxPostDataSize: MAX_EAGER_POST_REQUEST_BODY_LENGTH,
+            enableDurableMessages: Root.Runtime.hostConfig.devToolsEnableDurableMessages?.enabled,
+            maxTotalBufferSize: MAX_RESPONSE_BODY_TOTAL_BUFFER_LENGTH,
             reportDirectSocketTraffic: true,
         });
         void this.#networkAgent.invoke_setAttachDebugStack({ enabled: true });
@@ -321,13 +327,6 @@ export class NetworkManager extends SDKModel {
         }
         return result.status;
     }
-    async getIpProtectionProxyStatus() {
-        const result = await this.#networkAgent.invoke_getIPProtectionProxyStatus();
-        if (result.getError()) {
-            return null;
-        }
-        return result.status;
-    }
     async enableReportingApi(enable = true) {
         return await this.#networkAgent.invoke_enableReportingApi({ enable });
     }
@@ -364,6 +363,11 @@ export var Events;
  * @see https://docs.google.com/document/d/10lfVdS1iDWCRKQXPfbxEn4Or99D64mvNlugP1AQuFlE/edit for historical context.
  * @see https://crbug.com/342406608#comment10 for context around the addition of 4G presets in June 2024.
  */
+export const BlockingConditions = {
+    key: "BLOCKING" /* PredefinedThrottlingConditionKey.BLOCKING */,
+    block: true,
+    title: i18nLazyString(UIStrings.block),
+};
 export const NoThrottlingConditions = {
     key: "NO_THROTTLING" /* PredefinedThrottlingConditionKey.NO_THROTTLING */,
     title: i18nLazyString(UIStrings.noThrottling),
@@ -422,6 +426,7 @@ export const Fast4GConditions = {
     targetLatency: fast4GTargetLatency,
 };
 const MAX_EAGER_POST_REQUEST_BODY_LENGTH = 64 * 1024; // bytes
+const MAX_RESPONSE_BODY_TOTAL_BUFFER_LENGTH = 250 * 1024 * 1024; // bytes
 export class FetchDispatcher {
     #fetchAgent;
     #manager;
@@ -547,12 +552,6 @@ export class NetworkDispatcher {
         if (response.securityDetails) {
             networkRequest.setSecurityDetails(response.securityDetails);
         }
-        // TODO(crbug.com/425645896): Remove this guard once IP Protection is fully launched.
-        if (Root.Runtime.hostConfig.devToolsIpProtectionInDevTools?.enabled) {
-            if (response.isIpProtectionUsed) {
-                networkRequest.setIsIpProtectionUsed(response.isIpProtectionUsed);
-            }
-        }
         const newResourceType = Common.ResourceType.ResourceType.fromMimeTypeOverride(networkRequest.mimeType);
         if (newResourceType) {
             networkRequest.setResourceType(newResourceType);
@@ -811,7 +810,7 @@ export class NetworkDispatcher {
     }
     requestIntercepted({}) {
     }
-    requestWillBeSentExtraInfo({ requestId, associatedCookies, headers, clientSecurityState, connectTiming, siteHasCookieInOtherPartition }) {
+    requestWillBeSentExtraInfo({ requestId, associatedCookies, headers, clientSecurityState, connectTiming, siteHasCookieInOtherPartition, appliedNetworkConditionsId }) {
         const blockedRequestCookies = [];
         const includedRequestCookies = [];
         for (const { blockedReasons, exemptionReason, cookie } of associatedCookies) {
@@ -829,8 +828,14 @@ export class NetworkDispatcher {
             clientSecurityState,
             connectTiming,
             siteHasCookieInOtherPartition,
+            appliedNetworkConditionsId,
         };
         this.getExtraInfoBuilder(requestId).addRequestExtraInfo(extraRequestInfo);
+        const networkRequest = this.#requestsById.get(requestId);
+        if (appliedNetworkConditionsId && networkRequest) {
+            networkRequest.setAppliedNetworkConditions(appliedNetworkConditionsId);
+            this.updateNetworkRequest(networkRequest);
+        }
     }
     responseReceivedEarlyHints({ requestId, headers, }) {
         this.getExtraInfoBuilder(requestId).setEarlyHintsHeaders(this.headersMapToHeadersArray(headers));
@@ -1134,7 +1139,11 @@ export class NetworkDispatcher {
                 sendBufferSize: event.options.sendBufferSize,
                 receiveBufferSize: event.options.receiveBufferSize,
                 dnsQueryType: event.options.dnsQueryType,
-            }
+                multicastLoopback: event.options.multicastLoopback,
+                multicastTimeToLive: event.options.multicastTimeToLive,
+                multicastAllowAddressSharing: event.options.multicastAllowAddressSharing,
+            },
+            joinedMulticastGroups: new Set(),
         };
         networkRequest.setResourceType(Common.ResourceType.resourceTypes.DirectSocket);
         networkRequest.setIssueTime(event.timestamp, event.timestamp);
@@ -1220,45 +1229,35 @@ export class NetworkDispatcher {
         networkRequest.responseReceivedTime = event.timestamp;
         this.updateNetworkRequest(networkRequest);
     }
-    trustTokenOperationDone(event) {
-        const request = this.#requestsById.get(event.requestId);
-        if (!request) {
-            this.#requestIdToTrustTokenEvent.set(event.requestId, event);
+    directUDPSocketJoinedMulticastGroup(event) {
+        const networkRequest = this.#requestsById.get(event.identifier);
+        if (!networkRequest?.directSocketInfo) {
             return;
         }
-        request.setTrustTokenOperationDoneEvent(event);
-    }
-    subresourceWebBundleMetadataReceived({ requestId, urls }) {
-        const extraInfoBuilder = this.getExtraInfoBuilder(requestId);
-        extraInfoBuilder.setWebBundleInfo({ resourceUrls: urls });
-        const finalRequest = extraInfoBuilder.finalRequest();
-        if (finalRequest) {
-            this.updateNetworkRequest(finalRequest);
+        if (!networkRequest.directSocketInfo.joinedMulticastGroups) {
+            networkRequest.directSocketInfo.joinedMulticastGroups = new Set();
         }
-    }
-    subresourceWebBundleMetadataError({ requestId, errorMessage }) {
-        const extraInfoBuilder = this.getExtraInfoBuilder(requestId);
-        extraInfoBuilder.setWebBundleInfo({ errorMessage });
-        const finalRequest = extraInfoBuilder.finalRequest();
-        if (finalRequest) {
-            this.updateNetworkRequest(finalRequest);
+        if (!networkRequest.directSocketInfo.joinedMulticastGroups.has(event.IPAddress)) {
+            networkRequest.directSocketInfo.joinedMulticastGroups.add(event.IPAddress);
+            this.updateNetworkRequest(networkRequest);
         }
     }
-    subresourceWebBundleInnerResponseParsed({ innerRequestId, bundleRequestId }) {
-        const extraInfoBuilder = this.getExtraInfoBuilder(innerRequestId);
-        extraInfoBuilder.setWebBundleInnerRequestInfo({ bundleRequestId });
-        const finalRequest = extraInfoBuilder.finalRequest();
-        if (finalRequest) {
-            this.updateNetworkRequest(finalRequest);
+    directUDPSocketLeftMulticastGroup(event) {
+        const networkRequest = this.#requestsById.get(event.identifier);
+        if (!networkRequest?.directSocketInfo?.joinedMulticastGroups) {
+            return;
+        }
+        if (networkRequest.directSocketInfo.joinedMulticastGroups.delete(event.IPAddress)) {
+            this.updateNetworkRequest(networkRequest);
         }
     }
-    subresourceWebBundleInnerResponseError({ innerRequestId, errorMessage }) {
-        const extraInfoBuilder = this.getExtraInfoBuilder(innerRequestId);
-        extraInfoBuilder.setWebBundleInnerRequestInfo({ errorMessage });
-        const finalRequest = extraInfoBuilder.finalRequest();
-        if (finalRequest) {
-            this.updateNetworkRequest(finalRequest);
+    trustTokenOperationDone(event) {
+        const request = this.#requestsById.get(event.requestId);
+        if (!request) {
+            this.#requestIdToTrustTokenEvent.set(event.requestId, event);
+            return;
         }
+        request.setTrustTokenOperationDoneEvent(event);
     }
     reportingApiReportAdded(data) {
         this.#manager.dispatchEventToListeners(Events.ReportingApiReportAdded, data.report);
@@ -1287,8 +1286,335 @@ export class NetworkDispatcher {
         return `${host}:${port}`;
     }
 }
-let multiTargetNetworkManagerInstance;
+export class RequestURLPattern {
+    constructorString;
+    pattern;
+    constructor(constructorString, pattern) {
+        this.constructorString = constructorString;
+        this.pattern = pattern;
+        if (pattern.hasRegExpGroups) {
+            throw new Error('RegExp groups are not allowed');
+        }
+    }
+    static isValidPattern(pattern) {
+        try {
+            const urlPattern = new URLPattern(pattern);
+            return urlPattern.hasRegExpGroups ? "has-regexp-groups" /* RequestURLPatternValidity.HAS_REGEXP_GROUPS */ : "valid" /* RequestURLPatternValidity.VALID */;
+        }
+        catch {
+            return "failed-to-parse" /* RequestURLPatternValidity.FAILED_TO_PARSE */;
+        }
+    }
+    static create(constructorString) {
+        try {
+            const urlPattern = new URLPattern(constructorString);
+            return urlPattern.hasRegExpGroups ? null : new RequestURLPattern(constructorString, urlPattern);
+        }
+        catch {
+            return null;
+        }
+    }
+    static upgradeFromWildcard(pattern) {
+        const tryCreate = (constructorString) => {
+            const result = this.create(constructorString);
+            if (result?.pattern.protocol === 'localhost' && result?.pattern.hostname === '') {
+                // localhost:1234 parses as a valid pattern, do the right thing here instead
+                return tryCreate(`*://${constructorString}`);
+            }
+            return result;
+        };
+        return tryCreate(pattern) // try as is
+            ??
+                // Try to upgrade patterns created from the network panel, which either blocks the full url (sans
+                // protocol) or just the domain name. In both cases the wildcard patterns had implicit wildcards at the end.
+                // We explicitly add that here, which will match both domain names without path (implicitly setting pathname
+                // to '*') and urls with path (appending * to the pathname).
+                tryCreate(`*://${pattern}*`);
+    }
+}
+export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper {
+    #pattern;
+    #enabled;
+    #conditions;
+    #ruleIds = new Set();
+    static createFromSetting(setting) {
+        if ('urlPattern' in setting) {
+            const pattern = RequestURLPattern.create(setting.urlPattern) ?? {
+                wildcardURL: setting.urlPattern,
+                upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.urlPattern) ?? undefined,
+            };
+            const conditions = getPredefinedOrBlockingCondition(setting.conditions) ??
+                customUserNetworkConditionsSetting().get().find(condition => condition.key === setting.conditions) ??
+                NoThrottlingConditions;
+            return new this(pattern, setting.enabled, conditions);
+        }
+        const pattern = {
+            wildcardURL: setting.url,
+            upgradedPattern: RequestURLPattern.upgradeFromWildcard(setting.url) ?? undefined
+        };
+        return new this(pattern, setting.enabled, BlockingConditions);
+    }
+    static create(pattern, conditions) {
+        return new this(pattern, /* enabled=*/ true, conditions);
+    }
+    constructor(pattern, enabled, conditions) {
+        super();
+        this.#pattern = pattern;
+        this.#enabled = enabled;
+        this.#conditions = conditions;
+    }
+    get isBlocking() {
+        return this.conditions === BlockingConditions;
+    }
+    get ruleIds() {
+        return this.#ruleIds;
+    }
+    get constructorString() {
+        return this.#pattern instanceof RequestURLPattern ? this.#pattern.constructorString :
+            this.#pattern.upgradedPattern?.constructorString;
+    }
+    get wildcardURL() {
+        return 'wildcardURL' in this.#pattern ? this.#pattern.wildcardURL : undefined;
+    }
+    get constructorStringOrWildcardURL() {
+        return this.#pattern instanceof RequestURLPattern ?
+            this.#pattern.constructorString :
+            (this.#pattern.upgradedPattern?.constructorString ?? this.#pattern.wildcardURL);
+    }
+    set pattern(pattern) {
+        if (typeof pattern === 'string') {
+            // TODO(pfaffe) Remove once the feature flag is no longer required
+            if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+                throw new Error('Should not use wildcard urls');
+            }
+            this.#pattern = {
+                wildcardURL: pattern,
+                upgradedPattern: RequestURLPattern.upgradeFromWildcard(pattern) ?? undefined
+            };
+        }
+        else {
+            this.#pattern = pattern;
+        }
+        this.dispatchEventToListeners("request-condition-changed" /* RequestCondition.Events.REQUEST_CONDITION_CHANGED */);
+    }
+    get enabled() {
+        return this.#enabled;
+    }
+    set enabled(enabled) {
+        this.#enabled = enabled;
+        this.dispatchEventToListeners("request-condition-changed" /* RequestCondition.Events.REQUEST_CONDITION_CHANGED */);
+    }
+    get conditions() {
+        return this.#conditions;
+    }
+    set conditions(conditions) {
+        this.#conditions = conditions;
+        this.#ruleIds = new Set();
+        this.dispatchEventToListeners("request-condition-changed" /* RequestCondition.Events.REQUEST_CONDITION_CHANGED */);
+    }
+    toSetting() {
+        const enabled = this.enabled;
+        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() {
+        return this.#pattern instanceof RequestURLPattern ? this.#pattern.pattern : this.#pattern.upgradedPattern?.pattern;
+    }
+}
+export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper {
+    #setting = Common.Settings.Settings.instance().createSetting('network-blocked-patterns', []);
+    #conditionsEnabledSetting = Common.Settings.Settings.instance().moduleSetting('request-blocking-enabled');
+    #conditions = [];
+    #requestConditionsById = new Map();
+    #conditionsAppliedForTestPromise = Promise.resolve();
+    constructor() {
+        super();
+        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("request-condition-changed" /* RequestCondition.Events.REQUEST_CONDITION_CHANGED */, this.#conditionsChanged, this);
+        }
+        this.#conditionsEnabledSetting.addChangeListener(() => this.dispatchEventToListeners("request-conditions-changed" /* RequestConditions.Events.REQUEST_CONDITIONS_CHANGED */));
+    }
+    get count() {
+        return this.#conditions.length;
+    }
+    get conditionsEnabled() {
+        return this.#conditionsEnabledSetting.get();
+    }
+    set conditionsEnabled(enabled) {
+        if (this.#conditionsEnabledSetting.get() === enabled) {
+            return;
+        }
+        this.#conditionsEnabledSetting.set(enabled);
+    }
+    findCondition(pattern) {
+        if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+            return this.#conditions.find(condition => condition.constructorString === pattern);
+        }
+        return this.#conditions.find(condition => condition.wildcardURL === pattern);
+    }
+    has(url) {
+        return Boolean(this.findCondition(url));
+    }
+    add(...conditions) {
+        this.#conditions.push(...conditions);
+        for (const condition of conditions) {
+            condition.addEventListener("request-condition-changed" /* RequestCondition.Events.REQUEST_CONDITION_CHANGED */, this.#conditionsChanged, this);
+        }
+        this.#conditionsChanged();
+    }
+    decreasePriority(condition) {
+        const index = this.#conditions.indexOf(condition);
+        if (index < 0 || index >= this.#conditions.length - 1) {
+            return;
+        }
+        Platform.ArrayUtilities.swap(this.#conditions, index, index + 1);
+        this.#conditionsChanged();
+    }
+    increasePriority(condition) {
+        const index = this.#conditions.indexOf(condition);
+        if (index <= 0) {
+            return;
+        }
+        Platform.ArrayUtilities.swap(this.#conditions, index - 1, index);
+        this.#conditionsChanged();
+    }
+    delete(condition) {
+        const index = this.#conditions.indexOf(condition);
+        if (index < 0) {
+            return;
+        }
+        condition.removeEventListener("request-condition-changed" /* RequestCondition.Events.REQUEST_CONDITION_CHANGED */, this.#conditionsChanged, this);
+        this.#conditions.splice(index, 1);
+        this.#conditionsChanged();
+    }
+    clear() {
+        this.#conditions.splice(0);
+        this.#conditionsChanged();
+        for (const condition of this.#conditions) {
+            condition.removeEventListener("request-condition-changed" /* RequestCondition.Events.REQUEST_CONDITION_CHANGED */, this.#conditionsChanged, this);
+        }
+    }
+    #conditionsChanged() {
+        this.#setting.set(this.#conditions.map(condition => condition.toSetting()));
+        this.dispatchEventToListeners("request-conditions-changed" /* RequestConditions.Events.REQUEST_CONDITIONS_CHANGED */);
+    }
+    get conditions() {
+        return this.#conditions.values();
+    }
+    applyConditions(offline, globalConditions, ...agents) {
+        function isNonBlockingCondition(condition) {
+            return !('block' in condition);
+        }
+        if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
+            const urlPatterns = [];
+            // We store all this info out-of-band to prevent races with changing conditions while the promise is still pending
+            const matchedNetworkConditions = [];
+            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) {
+                        const { ruleIds } = condition;
+                        matchedNetworkConditions.push({ ruleIds, urlPattern, conditions });
+                    }
+                }
+                if (globalConditions) {
+                    matchedNetworkConditions.push({ conditions: globalConditions });
+                }
+            }
+            const promises = [];
+            for (const agent of agents) {
+                promises.push(agent.invoke_setBlockedURLs({ urlPatterns }));
+                promises.push(agent
+                    .invoke_emulateNetworkConditionsByRule({
+                    offline,
+                    matchedNetworkConditions: matchedNetworkConditions.map(({ urlPattern, conditions }) => ({
+                        urlPattern: 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),
+                    }))
+                })
+                    .then(response => {
+                    if (!response.getError()) {
+                        for (let i = 0; i < response.ruleIds.length; ++i) {
+                            const ruleId = response.ruleIds[i];
+                            const { ruleIds, conditions, urlPattern } = matchedNetworkConditions[i];
+                            if (ruleIds) {
+                                this.#requestConditionsById.set(ruleId, { urlPattern, conditions });
+                                matchedNetworkConditions[i].ruleIds?.add(ruleId);
+                            }
+                        }
+                    }
+                }));
+                promises.push(agent.invoke_overrideNetworkState({
+                    offline,
+                    latency: globalConditions?.latency ?? 0,
+                    downloadThroughput: globalConditions?.download ?? -1,
+                    uploadThroughput: globalConditions?.upload ?? -1,
+                    connectionType: globalConditions ? NetworkManager.connectionType(globalConditions) :
+                        "none" /* Protocol.Network.ConnectionType.None */,
+                }));
+            }
+            this.#conditionsAppliedForTestPromise = this.#conditionsAppliedForTestPromise.then(() => Promise.all(promises));
+            return urlPatterns.length > 0;
+        }
+        const urls = this.conditionsEnabled ?
+            this.#conditions.filter(condition => condition.enabled && condition.wildcardURL)
+                .map(condition => condition.wildcardURL) :
+            [];
+        for (const agent of agents) {
+            void agent.invoke_setBlockedURLs({ urls });
+        }
+        return urls.length > 0;
+    }
+    conditionsAppliedForTest() {
+        return this.#conditionsAppliedForTestPromise;
+    }
+    conditionsForId(appliedNetworkConditionsId) {
+        const requestConditions = this.#requestConditionsById.get(appliedNetworkConditionsId);
+        if (!requestConditions) {
+            return undefined;
+        }
+        const { conditions, urlPattern } = requestConditions;
+        return new AppliedNetworkConditions(conditions, appliedNetworkConditionsId, urlPattern);
+    }
+}
+_a = RequestConditions;
+export class AppliedNetworkConditions {
+    conditions;
+    appliedNetworkConditionsId;
+    urlPattern;
+    constructor(conditions, appliedNetworkConditionsId, urlPattern) {
+        this.conditions = conditions;
+        this.appliedNetworkConditionsId = appliedNetworkConditionsId;
+        this.urlPattern = urlPattern;
+    }
+}
 export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrapper {
+    #targetManager;
     #userAgentOverride = '';
     #userAgentMetadataOverride = null;
     #customAcceptedEncodings = null;
@@ -1297,33 +1623,32 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
     inflightMainResourceRequests = new Map();
     #networkConditions = NoThrottlingConditions;
     #updatingInterceptionPatternsPromise = null;
-    #blockingEnabledSetting = Common.Settings.Settings.instance().moduleSetting('request-blocking-enabled');
-    #blockedPatternsSetting = Common.Settings.Settings.instance().createSetting('network-blocked-patterns', []);
-    #effectiveBlockedURLs = [];
+    #requestConditions = new RequestConditions();
     #urlsForRequestInterceptor = new Platform.MapUtilities.Multimap();
     #extraHeaders;
     #customUserAgent;
-    constructor() {
+    #isBlocking = false;
+    constructor(targetManager) {
         super();
+        this.#targetManager = targetManager;
         // TODO(allada) Remove these and merge it with request interception.
         const blockedPatternChanged = () => {
             this.updateBlockedPatterns();
             this.dispatchEventToListeners("BlockedPatternsChanged" /* MultitargetNetworkManager.Events.BLOCKED_PATTERNS_CHANGED */);
         };
-        this.#blockingEnabledSetting.addChangeListener(blockedPatternChanged);
-        this.#blockedPatternsSetting.addChangeListener(blockedPatternChanged);
+        this.#requestConditions.addEventListener("request-conditions-changed" /* RequestConditions.Events.REQUEST_CONDITIONS_CHANGED */, blockedPatternChanged);
         this.updateBlockedPatterns();
-        TargetManager.instance().observeModels(NetworkManager, this);
+        this.#targetManager.observeModels(NetworkManager, this);
     }
     static instance(opts = { forceNew: null }) {
-        const { forceNew } = opts;
-        if (!multiTargetNetworkManagerInstance || forceNew) {
-            multiTargetNetworkManagerInstance = new MultitargetNetworkManager();
+        const { forceNew, targetManager } = opts;
+        if (!Root.DevToolsContext.globalInstance().has(MultitargetNetworkManager) || forceNew) {
+            Root.DevToolsContext.globalInstance().set(MultitargetNetworkManager, new MultitargetNetworkManager(targetManager ?? TargetManager.instance()));
         }
-        return multiTargetNetworkManagerInstance;
+        return Root.DevToolsContext.globalInstance().get(MultitargetNetworkManager);
     }
     static dispose() {
-        multiTargetNetworkManagerInstance = null;
+        Root.DevToolsContext.globalInstance().delete(MultitargetNetworkManager);
     }
     static patchUserAgentWithChromeVersion(uaString) {
         // Patches Chrome/ChrOS version from user #agent ("1.2.3.4" when user #agent is: "Chrome/1.2.3.4").
@@ -1367,9 +1692,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
         if (this.currentUserAgent()) {
             void networkAgent.invoke_setUserAgentOverride({ userAgent: this.currentUserAgent(), userAgentMetadata: this.#userAgentMetadataOverride || undefined });
         }
-        if (this.#effectiveBlockedURLs.length) {
-            void networkAgent.invoke_setBlockedURLs({ urls: this.#effectiveBlockedURLs });
-        }
+        this.#requestConditions.applyConditions(this.isOffline(), this.isThrottling() ? this.#networkConditions : null, networkAgent);
         if (this.isIntercepting()) {
             void fetchAgent.invoke_enable({ patterns: this.#urlsForRequestInterceptor.valuesArray() });
         }
@@ -1381,7 +1704,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);
         }
     }
@@ -1405,8 +1728,13 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
     }
     setNetworkConditions(conditions) {
         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("ConditionsChanged" /* MultitargetNetworkManager.Events.CONDITIONS_CHANGED */);
     }
@@ -1494,41 +1822,29 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
             }
         }
     }
-    // TODO(allada) Move all request blocking into interception and let view manage blocking.
-    blockedPatterns() {
-        return this.#blockedPatternsSetting.get().slice();
-    }
-    blockingEnabled() {
-        return this.#blockingEnabledSetting.get();
+    get requestConditions() {
+        return this.#requestConditions;
     }
     isBlocking() {
-        return Boolean(this.#effectiveBlockedURLs.length);
-    }
-    setBlockedPatterns(patterns) {
-        this.#blockedPatternsSetting.set(patterns);
+        return this.#isBlocking && this.requestConditions.conditionsEnabled;
     }
+    /**
+     * @deprecated Kept for layout tests
+     * TODO(pfaffe) remove
+     */
     setBlockingEnabled(enabled) {
-        if (this.#blockingEnabledSetting.get() === enabled) {
-            return;
-        }
-        this.#blockingEnabledSetting.set(enabled);
+        this.requestConditions.conditionsEnabled = enabled;
+    }
+    /**
+     * @deprecated Kept for layout tests
+     * TODO(pfaffe) remove
+     */
+    setBlockedPatterns(patterns) {
+        this.requestConditions.clear();
+        this.requestConditions.add(...patterns.map(pattern => RequestCondition.createFromSetting(pattern)));
     }
     updateBlockedPatterns() {
-        const urls = [];
-        if (this.#blockingEnabledSetting.get()) {
-            for (const pattern of this.#blockedPatternsSetting.get()) {
-                if (pattern.enabled) {
-                    urls.push(pattern.url);
-                }
-            }
-        }
-        if (!urls.length && !this.#effectiveBlockedURLs.length) {
-            return;
-        }
-        this.#effectiveBlockedURLs = urls;
-        for (const agent of this.#networkAgents) {
-            void agent.invoke_setBlockedURLs({ urls: this.#effectiveBlockedURLs });
-        }
+        this.#isBlocking = this.#requestConditions.applyConditions(this.isOffline(), this.isThrottling() ? this.#networkConditions : null, ...this.#networkAgents);
     }
     isIntercepting() {
         return Boolean(this.#urlsForRequestInterceptor.size);
@@ -1583,7 +1899,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
         }
     }
     async getCertificate(origin) {
-        const target = TargetManager.instance().primaryPageTarget();
+        const target = this.#targetManager.primaryPageTarget();
         if (!target) {
             return [];
         }
@@ -1593,19 +1909,11 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
         }
         return certificate.tableNames;
     }
-    async loadResource(url) {
-        const headers = {};
-        const currentUserAgent = this.currentUserAgent();
-        if (currentUserAgent) {
-            headers['User-Agent'] = currentUserAgent;
+    appliedRequestConditions(requestInternal) {
+        if (!requestInternal.appliedNetworkConditionsId) {
+            return undefined;
         }
-        if (Common.Settings.Settings.instance().moduleSetting('cache-disabled').get()) {
-            headers['Cache-Control'] = 'no-cache';
-        }
-        const allowRemoteFilePaths = Common.Settings.Settings.instance().moduleSetting('network.enable-remote-file-loading').get();
-        return await new Promise(resolve => Host.ResourceLoader.load(url, headers, (success, _responseHeaders, content, errorDescription) => {
-            resolve({ success, content, errorDescription });
-        }, allowRemoteFilePaths));
+        return this.requestConditions.conditionsForId(requestInternal.appliedNetworkConditionsId);
     }
 }
 export class InterceptedRequest {
@@ -1747,8 +2055,6 @@ class ExtraInfoBuilder {
     #responseExtraInfos = [];
     #responseEarlyHintsHeaders = [];
     #finished = false;
-    #webBundleInfo = null;
-    #webBundleInnerRequestInfo = null;
     addRequest(req) {
         this.#requests.push(req);
         this.sync(this.#requests.length - 1);
@@ -1779,14 +2085,6 @@ class ExtraInfoBuilder {
         this.#responseEarlyHintsHeaders = earlyHintsHeaders;
         this.updateFinalRequest();
     }
-    setWebBundleInfo(info) {
-        this.#webBundleInfo = info;
-        this.updateFinalRequest();
-    }
-    setWebBundleInnerRequestInfo(info) {
-        this.#webBundleInnerRequestInfo = info;
-        this.updateFinalRequest();
-    }
     finished() {
         this.#finished = true;
         // We may have missed responseReceived event in case of failure.
@@ -1839,13 +2137,19 @@ class ExtraInfoBuilder {
             return;
         }
         const finalRequest = this.finalRequest();
-        finalRequest?.setWebBundleInfo(this.#webBundleInfo);
-        finalRequest?.setWebBundleInnerRequestInfo(this.#webBundleInnerRequestInfo);
         finalRequest?.setEarlyHintsHeaders(this.#responseEarlyHintsHeaders);
     }
 }
 SDKModel.register(NetworkManager, { capabilities: 16 /* Capability.NETWORK */, autostart: true });
 export function networkConditionsEqual(first, second) {
+    if ('block' in first || 'block' in second) {
+        if ('block' in first && 'block' in second) {
+            const firstTitle = (typeof first.title === 'function' ? first.title() : first.title);
+            const secondTitle = (typeof second.title === 'function' ? second.title() : second.title);
+            return firstTitle === secondTitle && first.block === second.block;
+        }
+        return false;
+    }
     // Caution: titles might be different function instances, which produce
     // the same value.
     // We prefer to use the i18nTitleKey to prevent against locale changes or
@@ -1876,6 +2180,9 @@ export function getPredefinedCondition(key) {
     }
     return THROTTLING_CONDITIONS_LOOKUP.get(key) ?? null;
 }
+export function getPredefinedOrBlockingCondition(key) {
+    return key === "BLOCKING" /* PredefinedThrottlingConditionKey.BLOCKING */ ? BlockingConditions : getPredefinedCondition(key);
+}
 /**
  * For the given Round Trip Time (in MilliSeconds), return the best throttling conditions.
  */