chrome-devtools-frontend 1.0.1532884 → 1.0.1533544

package/front_end/core/sdk/NetworkManager.ts

@@ -1022,9 +1022,15 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
   requestIntercepted({}: Protocol.Network.RequestInterceptedEvent): void {
   }
 
-  requestWillBeSentExtraInfo(
-      {requestId, associatedCookies, headers, clientSecurityState, connectTiming, siteHasCookieInOtherPartition}:
-          Protocol.Network.RequestWillBeSentExtraInfoEvent): void {
+  requestWillBeSentExtraInfo({
+    requestId,
+    associatedCookies,
+    headers,
+    clientSecurityState,
+    connectTiming,
+    siteHasCookieInOtherPartition,
+    appliedNetworkConditionsId
+  }: Protocol.Network.RequestWillBeSentExtraInfoEvent): void {
     const blockedRequestCookies: BlockedCookieWithReason[] = [];
     const includedRequestCookies: IncludedCookieWithReason[] = [];
     for (const {blockedReasons, exemptionReason, cookie} of associatedCookies) {
@@ -1041,6 +1047,7 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
       clientSecurityState,
       connectTiming,
       siteHasCookieInOtherPartition,
+      appliedNetworkConditionsId,
     };
     this.getExtraInfoBuilder(requestId).addRequestExtraInfo(extraRequestInfo);
   }
@@ -1575,24 +1582,6 @@ export type RequestConditionsSetting = {
   enabled: boolean,
 };
 
-declare global {
-  // TS typedefs are not up to date
-  interface URLPattern {
-    hash: string;
-    hostname: string;
-    password: string;
-    pathname: string;
-    port: string;
-    protocol: string;
-    search: string;
-    username: string;
-    hasRegExpGroups: boolean;
-    test(url: string): boolean;
-  }
-  /* eslint-disable-next-line @typescript-eslint/naming-convention */
-  var URLPattern: {prototype: URLPattern, new (input: string): URLPattern};
-}
-
 export type URLPatternConstructorString = Platform.Brand.Brand<string, 'URLPatternConstructorString'>;
 
 export const enum RequestURLPatternValidity {
@@ -1650,6 +1639,7 @@ export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<Request
   #pattern: RequestURLPattern|{wildcardURL: string, upgradedPattern?: RequestURLPattern};
   #enabled: boolean;
   #conditions: ThrottlingConditions;
+  #ruleIds = new Set<string>();
 
   static createFromSetting(setting: RequestConditionsSetting): RequestCondition {
     if ('urlPattern' in setting) {
@@ -1685,6 +1675,14 @@ export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<Request
     this.#conditions = conditions;
   }
 
+  get isBlocking(): boolean {
+    return this.conditions === BlockingConditions;
+  }
+
+  get ruleIds(): Set<string> {
+    return this.#ruleIds;
+  }
+
   get constructorString(): string|undefined {
     return this.#pattern instanceof RequestURLPattern ? this.#pattern.constructorString :
                                                         this.#pattern.upgradedPattern?.constructorString;
@@ -1731,6 +1729,7 @@ export class RequestCondition extends Common.ObjectWrapper.ObjectWrapper<Request
 
   set conditions(conditions: ThrottlingConditions) {
     this.#conditions = conditions;
+    this.#ruleIds = new Set();
     this.dispatchEventToListeners(RequestCondition.Events.REQUEST_CONDITION_CHANGED);
   }
 
@@ -1766,6 +1765,11 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
   readonly #conditionsEnabledSetting =
       Common.Settings.Settings.instance().moduleSetting<boolean>('request-blocking-enabled');
   readonly #conditions: RequestCondition[] = [];
+  readonly #requestConditionsById = new Map<string, {
+    conditions: Conditions,
+    urlPattern?: string,
+  }>();
+  #conditionsAppliedForTestPromise: Promise<unknown> = Promise.resolve();
 
   constructor() {
     super();
@@ -1871,7 +1875,8 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
     }
     if (Root.Runtime.hostConfig.devToolsIndividualRequestThrottling?.enabled) {
       const urlPatterns: Protocol.Network.BlockPattern[] = [];
-      const matchedNetworkConditions: Protocol.Network.NetworkConditions[] = [];
+      // We store all this info out-of-band to prevent races with changing conditions while the promise is still pending
+      const matchedNetworkConditions: Array<{conditions: Conditions, ruleIds?: Set<string>, urlPattern?: string}> = [];
       if (this.conditionsEnabled) {
         for (const condition of this.#conditions) {
           const urlPattern = condition.constructorString;
@@ -1882,43 +1887,56 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
           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),
-            });
+            const {ruleIds} = condition;
+            matchedNetworkConditions.push({ruleIds, urlPattern, 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),
-          });
+          matchedNetworkConditions.push({conditions: globalConditions});
         }
       }
 
+      const promises: Array<Promise<unknown>> = [];
+
       for (const agent of agents) {
-        void agent.invoke_setBlockedURLs({urlPatterns});
-        void agent.invoke_emulateNetworkConditionsByRule({offline, matchedNetworkConditions});
-        void agent.invoke_overrideNetworkState({
+        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 || globalConditions.download < 0 ? 0 : globalConditions.download,
           uploadThroughput: !globalConditions || globalConditions.upload < 0 ? 0 : globalConditions.upload,
-        });
+        }));
       }
+
+      this.#conditionsAppliedForTestPromise = this.#conditionsAppliedForTestPromise.then(() => Promise.all(promises));
       return urlPatterns.length > 0;
     }
 
@@ -1932,6 +1950,17 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
     }
     return urls.length > 0;
   }
+
+  conditionsAppliedForTest(): Promise<unknown> {
+    return this.#conditionsAppliedForTestPromise;
+  }
+
+  conditionsForId(appliedNetworkConditionsId: string): {
+    conditions: Conditions,
+    urlPattern?: string,
+  }|undefined {
+    return this.#requestConditionsById.get(appliedNetworkConditionsId);
+  }
 }
 
 export namespace RequestConditions {
@@ -2313,6 +2342,16 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
           resolve({success, content, errorDescription});
         }, allowRemoteFilePaths));
   }
+
+  appliedRequestConditions(requestInternal: NetworkRequest): {
+    conditions: Conditions,
+    urlPattern?: string,
+  }|undefined {
+    if (!requestInternal.appliedNetworkConditionsId) {
+      return undefined;
+    }
+    return this.requestConditions.conditionsForId(requestInternal.appliedNetworkConditionsId);
+  }
 }
 
 export namespace MultitargetNetworkManager {

package/front_end/core/sdk/NetworkRequest.ts

@@ -319,6 +319,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
   readonly #directSocketChunks: DirectSocketChunk[] = [];
   #isIpProtectionUsed: boolean;
   #isAdRelated: boolean;
+  #appliedNetworkConditionsId?: string;
 
   constructor(
       requestId: string,
@@ -455,6 +456,10 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     return this.#loaderId;
   }
 
+  get appliedNetworkConditionsId(): string|undefined {
+    return this.#appliedNetworkConditionsId;
+  }
+
   setRemoteAddress(ip: string, port: number): void {
     this.#remoteAddress = ip + ':' + port;
     this.dispatchEventToListeners(Events.REMOTE_ADDRESS_CHANGED, this);
@@ -1613,6 +1618,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
     this.#hasExtraRequestInfo = true;
     this.setRequestHeadersText('');  // Mark request headers as non-provisional
     this.#clientSecurityState = extraRequestInfo.clientSecurityState;
+    this.#appliedNetworkConditionsId = extraRequestInfo.appliedNetworkConditionsId;
     if (extraRequestInfo.connectTiming) {
       this.setConnectTimingFromExtraInfo(extraRequestInfo.connectTiming);
     }
@@ -2170,6 +2176,7 @@ export interface ExtraRequestInfo {
   clientSecurityState?: Protocol.Network.ClientSecurityState;
   connectTiming: Protocol.Network.ConnectTiming;
   siteHasCookieInOtherPartition?: boolean;
+  appliedNetworkConditionsId?: string;
 }
 
 export interface ExtraResponseInfo {