chrome-devtools-frontend 1.0.1532228 → 1.0.1533544

package/front_end/core/sdk/ChildTargetManager.ts

@@ -36,7 +36,7 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   readonly #targetInfos = new Map<Protocol.Target.TargetID, Protocol.Target.TargetInfo>();
   readonly #childTargetsBySessionId = new Map<Protocol.Target.SessionID, Target>();
   readonly #childTargetsById = new Map<Protocol.Target.TargetID|'main', Target>();
-  readonly #parallelConnections = new Map<string, ProtocolClient.InspectorBackend.Connection>();
+  readonly #parallelConnections = new Map<string, ProtocolClient.ConnectionTransport.ConnectionTransport>();
   #parentTargetId: Protocol.Target.TargetID|null = null;
 
   constructor(parentTarget: Target) {
@@ -261,7 +261,7 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   }
 
   async createParallelConnection(onMessage: (arg0: Object|string) => void):
-      Promise<{connection: ProtocolClient.InspectorBackend.Connection, sessionId: string}> {
+      Promise<{connection: ProtocolClient.ConnectionTransport.ConnectionTransport, sessionId: string}> {
     // The main Target id is actually just `main`, instead of the real targetId.
     // Get the real id (requires an async operation) so that it can be used synchronously later.
     const targetId = await this.getParentTargetId();
@@ -274,7 +274,7 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
 
   private async createParallelConnectionAndSessionForTarget(target: Target, targetId: Protocol.Target.TargetID):
       Promise<{
-        connection: ProtocolClient.InspectorBackend.Connection,
+        connection: ProtocolClient.ConnectionTransport.ConnectionTransport,
         sessionId: string,
       }> {
     const targetAgent = target.targetAgent();

package/front_end/core/sdk/Connections.ts

@@ -19,7 +19,7 @@ const UIStrings = {
 } as const;
 const str_ = i18n.i18n.registerUIStrings('core/sdk/Connections.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-export class MainConnection implements ProtocolClient.InspectorBackend.Connection {
+export class MainConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
   onMessage: ((arg0: Object|string) => void)|null = null;
   #onDisconnect: ((arg0: string) => void)|null = null;
   #messageBuffer = '';
@@ -81,7 +81,7 @@ export class MainConnection implements ProtocolClient.InspectorBackend.Connectio
   }
 }
 
-export class WebSocketConnection implements ProtocolClient.InspectorBackend.Connection {
+export class WebSocketConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
   #socket: WebSocket|null;
   onMessage: ((arg0: Object|string) => void)|null = null;
   #onDisconnect: ((arg0: string) => void)|null = null;
@@ -176,7 +176,7 @@ export class WebSocketConnection implements ProtocolClient.InspectorBackend.Conn
   }
 }
 
-export class StubConnection implements ProtocolClient.InspectorBackend.Connection {
+export class StubConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
   onMessage: ((arg0: Object|string) => void)|null = null;
   #onDisconnect: ((arg0: string) => void)|null = null;
 
@@ -213,17 +213,17 @@ export class StubConnection implements ProtocolClient.InspectorBackend.Connectio
   }
 }
 
-export interface ParallelConnectionInterface extends ProtocolClient.InspectorBackend.Connection {
+export interface ParallelConnectionInterface extends ProtocolClient.ConnectionTransport.ConnectionTransport {
   getSessionId: () => string;
   getOnDisconnect: () => ((arg0: string) => void) | null;
 }
 
 export class ParallelConnection implements ParallelConnectionInterface {
-  readonly #connection: ProtocolClient.InspectorBackend.Connection;
+  readonly #connection: ProtocolClient.ConnectionTransport.ConnectionTransport;
   #sessionId: string;
   onMessage: ((arg0: Object) => void)|null = null;
   #onDisconnect: ((arg0: string) => void)|null = null;
-  constructor(connection: ProtocolClient.InspectorBackend.Connection, sessionId: string) {
+  constructor(connection: ProtocolClient.ConnectionTransport.ConnectionTransport, sessionId: string) {
     this.#connection = connection;
     this.#sessionId = sessionId;
   }
@@ -265,13 +265,13 @@ export class ParallelConnection implements ParallelConnectionInterface {
 export async function initMainConnection(
     createRootTarget: () => Promise<void>,
     onConnectionLost: (message: Platform.UIString.LocalizedString) => void): Promise<void> {
-  ProtocolClient.InspectorBackend.Connection.setFactory(createMainConnection.bind(null, onConnectionLost));
+  ProtocolClient.ConnectionTransport.ConnectionTransport.setFactory(createMainConnection.bind(null, onConnectionLost));
   await createRootTarget();
   Host.InspectorFrontendHost.InspectorFrontendHostInstance.connectionReady();
 }
 
 function createMainConnection(onConnectionLost: (message: Platform.UIString.LocalizedString) => void):
-    ProtocolClient.InspectorBackend.Connection {
+    ProtocolClient.ConnectionTransport.ConnectionTransport {
   if (Root.Runtime.Runtime.isTraceApp()) {
     return new RehydratingConnection(onConnectionLost);
   }

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();
@@ -1817,6 +1821,26 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
     this.#conditionsChanged();
   }
 
+  decreasePriority(condition: RequestCondition): void {
+    const index = this.#conditions.indexOf(condition);
+    if (index < 0 || index >= this.#conditions.length - 1) {
+      return;
+    }
+
+    Platform.ArrayUtilities.swap(this.#conditions, index, index + 1);
+    this.dispatchEventToListeners(RequestConditions.Events.REQUEST_CONDITIONS_CHANGED);
+  }
+
+  increasePriority(condition: RequestCondition): void {
+    const index = this.#conditions.indexOf(condition);
+    if (index <= 0) {
+      return;
+    }
+
+    Platform.ArrayUtilities.swap(this.#conditions, index - 1, index);
+    this.dispatchEventToListeners(RequestConditions.Events.REQUEST_CONDITIONS_CHANGED);
+  }
+
   delete(condition: RequestCondition): void {
     const index = this.#conditions.indexOf(condition);
     if (index < 0) {
@@ -1851,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;
@@ -1862,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;
     }
 
@@ -1912,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 {
@@ -2293,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 {

package/front_end/core/sdk/RehydratingConnection.ts

@@ -63,7 +63,7 @@ export const enum RehydratingConnectionState {
   REHYDRATED = 3,
 }
 
-export class RehydratingConnection implements ProtocolClient.InspectorBackend.Connection {
+export class RehydratingConnection implements ProtocolClient.ConnectionTransport.ConnectionTransport {
   rehydratingConnectionState: RehydratingConnectionState = RehydratingConnectionState.UNINITIALIZED;
   onDisconnect: ((arg0: string) => void)|null = null;
   onMessage: ((arg0: Object) => void)|null = null;
@@ -106,11 +106,13 @@ export class RehydratingConnection implements ProtocolClient.InspectorBackend.Co
 
   #setupMessagePassing(): void {
     this.#rehydratingWindow.addEventListener('message', this.#onReceiveHostWindowPayloadBound);
-    if (!this.#rehydratingWindow.opener) {
+    if (this.#rehydratingWindow.opener) {
+      this.#rehydratingWindow.opener.postMessage({type: 'REHYDRATING_WINDOW_READY'});
+    } else if (this.#rehydratingWindow !== window.top) {
+      this.#rehydratingWindow.parent.postMessage({type: 'REHYDRATING_IFRAME_READY'});
+    } else {
       this.#onConnectionLost(i18nString(UIStrings.noHostWindow));
-      return;
     }
-    this.#rehydratingWindow.opener.postMessage({type: 'REHYDRATING_WINDOW_READY'});
   }
 
   /**

package/front_end/core/sdk/Target.ts

@@ -39,7 +39,8 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
   constructor(
       targetManager: TargetManager, id: Protocol.Target.TargetID|'main', name: string, type: Type,
       parentTarget: Target|null, sessionId: string, suspended: boolean,
-      connection: ProtocolClient.InspectorBackend.Connection|null, targetInfo?: Protocol.Target.TargetInfo) {
+      connection: ProtocolClient.ConnectionTransport.ConnectionTransport|null,
+      targetInfo?: Protocol.Target.TargetInfo) {
     const needsNodeJSPatching = type === Type.NODE;
     super(needsNodeJSPatching, parentTarget, sessionId, connection);
     this.#targetManager = targetManager;

package/front_end/core/sdk/TargetManager.ts

@@ -209,7 +209,8 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
 
   createTarget(
       id: Protocol.Target.TargetID|'main', name: string, type: TargetType, parentTarget: Target|null,
-      sessionId?: string, waitForDebuggerInPage?: boolean, connection?: ProtocolClient.InspectorBackend.Connection,
+      sessionId?: string, waitForDebuggerInPage?: boolean,
+      connection?: ProtocolClient.ConnectionTransport.ConnectionTransport,
       targetInfo?: Protocol.Target.TargetInfo): Target {
     const target = new Target(
         this, id, name, type, parentTarget, sessionId || '', this.#isSuspended, connection || null, targetInfo);