chrome-devtools-frontend 1.0.1033742 → 1.0.1034366

package/front_end/core/root/Runtime.ts

@@ -120,18 +120,21 @@ export class ExperimentsSupport {
   #enabledTransiently: Set<string>;
   readonly #enabledByDefault: Set<string>;
   readonly #serverEnabled: Set<string>;
+  // Experiments in this set won't be shown to the user
+  readonly #nonConfigurable: Set<string>;
   constructor() {
     this.#experiments = [];
     this.#experimentNames = new Set();
     this.#enabledTransiently = new Set();
     this.#enabledByDefault = new Set();
     this.#serverEnabled = new Set();
+    this.#nonConfigurable = new Set();
   }
 
   allConfigurableExperiments(): Experiment[] {
     const result = [];
     for (const experiment of this.#experiments) {
-      if (!this.#enabledTransiently.has(experiment.name)) {
+      if (!this.#enabledTransiently.has(experiment.name) && !this.#nonConfigurable.has(experiment.name)) {
         result.push(experiment);
       }
     }
@@ -203,6 +206,13 @@ export class ExperimentsSupport {
     }
   }
 
+  setNonConfigurableExperiments(experimentNames: string[]): void {
+    for (const experiment of experimentNames) {
+      this.checkExperiment(experiment);
+      this.#nonConfigurable.add(experiment);
+    }
+  }
+
   enableForTest(experimentName: string): void {
     this.checkExperiment(experimentName);
     this.#enabledTransiently.add(experimentName);

package/front_end/core/sdk/NetworkManager.ts

@@ -465,10 +465,10 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
       networkRequest.setUrl(response.url as Platform.DevToolsPath.UrlString);
     }
     networkRequest.mimeType = (response.mimeType as MIME_TYPE);
-    if (!networkRequest.statusCode) {
+    if (!networkRequest.statusCode || networkRequest.wasIntercepted()) {
       networkRequest.statusCode = response.status;
     }
-    if (!networkRequest.statusText) {
+    if (!networkRequest.statusText || networkRequest.wasIntercepted()) {
       networkRequest.statusText = response.statusText;
     }
     if (!networkRequest.hasExtraResponseInfo() || networkRequest.wasIntercepted()) {
@@ -1170,6 +1170,10 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
     return multiTargetNetworkManagerInstance;
   }
 
+  static dispose(): void {
+    multiTargetNetworkManagerInstance = null;
+  }
+
   static getChromeVersion(): string {
     const chromeRegex = /(?:^|\W)(?:Chrome|HeadlessChrome)\/(\S+)/;
     const chromeMatch = navigator.userAgent.match(chromeRegex);
@@ -1523,6 +1527,7 @@ export namespace MultitargetNetworkManager {
     InterceptorsChanged = 'InterceptorsChanged',
     AcceptedEncodingsChanged = 'AcceptedEncodingsChanged',
     RequestIntercepted = 'RequestIntercepted',
+    RequestFulfilled = 'RequestFulfilled',
   }
 
   export type EventTypes = {
@@ -1532,6 +1537,7 @@ export namespace MultitargetNetworkManager {
     [Events.InterceptorsChanged]: void,
     [Events.AcceptedEncodingsChanged]: void,
     [Events.RequestIntercepted]: Platform.DevToolsPath.UrlString,
+    [Events.RequestFulfilled]: Platform.DevToolsPath.UrlString,
   };
 }
 
@@ -1565,11 +1571,15 @@ export class InterceptedRequest {
     return this.#hasRespondedInternal;
   }
 
-  async continueRequestWithContent(contentBlob: Blob, encoded: boolean, responseHeaders: Protocol.Fetch.HeaderEntry[]):
-      Promise<void> {
+  async continueRequestWithContent(
+      contentBlob: Blob, encoded: boolean, responseHeaders: Protocol.Fetch.HeaderEntry[],
+      isBodyOverridden: boolean): Promise<void> {
     this.#hasRespondedInternal = true;
     const body = encoded ? await contentBlob.text() : await blobToBase64(contentBlob);
-    void this.#fetchAgent.invoke_fulfillRequest({requestId: this.requestId, responseCode: 200, body, responseHeaders});
+    const responseCode = isBodyOverridden ? 200 : (this.responseStatusCode || 200);
+    void this.#fetchAgent.invoke_fulfillRequest({requestId: this.requestId, responseCode, body, responseHeaders});
+    MultitargetNetworkManager.instance().dispatchEventToListeners(
+        MultitargetNetworkManager.Events.RequestFulfilled, this.request.url as Platform.DevToolsPath.UrlString);
 
     async function blobToBase64(blob: Blob): Promise<string> {
       const reader = new FileReader();
@@ -1608,6 +1618,10 @@ export class InterceptedRequest {
     const error = response.getError() || null;
     return {error: error, content: error ? null : response.body, encoded: response.base64Encoded};
   }
+
+  isRedirect(): boolean {
+    return this.responseStatusCode !== undefined && this.responseStatusCode >= 300 && this.responseStatusCode < 400;
+  }
 }
 
 /**

package/front_end/entrypoints/lighthouse_worker/LighthouseWorkerService.ts

@@ -125,7 +125,7 @@ async function invokeLH(action: string, args: any): Promise<unknown> {
     }
 
     // @ts-expect-error https://github.com/GoogleChrome/lighthouse/issues/11628
-    const config = self.createConfig(args.categoryIDs, flags.emulatedFormFactor);
+    const config = args.config || self.createConfig(args.categoryIDs, flags.emulatedFormFactor);
     const url = args.url;
 
     // Handle legacy Lighthouse runner path.

package/front_end/entrypoints/main/MainImpl.ts

@@ -426,10 +426,14 @@ export class MainImpl {
       'reportingApiDebugging',
       Root.Runtime.ExperimentName.SYNC_SETTINGS,
       Root.Runtime.ExperimentName.CSS_LAYERS,
-      Root.Runtime.ExperimentName.EYEDROPPER_COLOR_PICKER,
+      ...('EyeDropper' in window ? [Root.Runtime.ExperimentName.EYEDROPPER_COLOR_PICKER] : []),
       'lighthousePanelFR',
     ]);
 
+    Root.Runtime.experiments.setNonConfigurableExperiments([
+      ...(!('EyeDropper' in window) ? [Root.Runtime.ExperimentName.EYEDROPPER_COLOR_PICKER] : []),
+    ]);
+
     Root.Runtime.experiments.cleanUpStaleExperiments();
     const enabledExperiments = Root.Runtime.Runtime.queryParam('enabledExperiments');
     if (enabledExperiments) {

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -731,13 +731,17 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
       const blob = await project.requestFileBlob(fileSystemUISourceCode);
       if (blob) {
         void interceptedRequest.continueRequestWithContent(
-            new Blob([blob], {type: mimeType}), /* encoded */ false, responseHeaders);
+            new Blob([blob], {type: mimeType}), /* encoded */ false, responseHeaders, /* isBodyOverridden */ true);
       }
+    } else if (interceptedRequest.isRedirect()) {
+      void interceptedRequest.continueRequestWithContent(
+          new Blob([], {type: mimeType}), /* encoded */ true, responseHeaders, /* isBodyOverridden */ false);
     } else {
       const responseBody = await interceptedRequest.responseBody();
       if (!responseBody.error && responseBody.content) {
         void interceptedRequest.continueRequestWithContent(
-            new Blob([responseBody.content], {type: mimeType}), /* encoded */ true, responseHeaders);
+            new Blob([responseBody.content], {type: mimeType}), /* encoded */ true, responseHeaders,
+            /* isBodyOverridden */ false);
       }
     }
   }

package/front_end/panels/lighthouse/LighthouseProtocolService.ts

@@ -63,6 +63,7 @@ export class ProtocolService {
   private parallelConnection?: ProtocolClient.InspectorBackend.Connection;
   private lighthouseWorkerPromise?: Promise<Worker>;
   private lighthouseMessageUpdateCallback?: ((arg0: string) => void);
+  private configForTesting?: Object;
 
   async attach(): Promise<void> {
     await SDK.TargetManager.TargetManager.instance().suspendAllTargets();
@@ -113,6 +114,7 @@ export class ProtocolService {
       url: inspectedURL,
       categoryIDs,
       flags,
+      config: this.configForTesting,
       locales: this.getLocales(),
       target: this.targetInfo,
     });
@@ -134,6 +136,7 @@ export class ProtocolService {
       url: inspectedURL,
       categoryIDs,
       flags,
+      config: this.configForTesting,
       locales: this.getLocales(),
       target: this.targetInfo,
     });
@@ -241,7 +244,7 @@ export class ProtocolService {
   }
 
   /** sendWithResponse currently only handles the original startLighthouse request and LHR-filled response. */
-  private async sendWithResponse(action: string, args: {[x: string]: string|string[]|Object} = {}):
+  private async sendWithResponse(action: string, args: {[x: string]: string|string[]|Object|undefined} = {}):
       Promise<ReportRenderer.RunnerResult> {
     const worker = await this.ensureWorkerExists();
     const messageId = lastId++;

package/package.json

@@ -56,5 +56,5 @@
     "unittest": "scripts/test/run_unittests.py --no-text-coverage",
     "watch": "vpython third_party/node/node.py --output scripts/watch_build.js"
   },
-  "version": "1.0.1033742"
+  "version": "1.0.1034366"
 }