lighthouse 8.4.0 → 8.5.0-dev.20210921

package/lighthouse-core/gather/driver/prepare.js

@@ -88,25 +88,25 @@ async function resetStorageForNavigation(session, navigation) {
 }
 
 /**
- * Prepares a target for a particular navigation by resetting storage and setting throttling.
+ * Prepares a target for observational analysis by setting throttling and network headers/blocked patterns.
  *
- * This method assumes `prepareTargetForNavigationMode` has already been invoked.
+ * This method assumes `prepareTargetForNavigationMode` or `prepareTargetForTimespanMode` has already been invoked.
  *
  * @param {LH.Gatherer.FRProtocolSession} session
  * @param {LH.Config.Settings} settings
- * @param {Pick<LH.Config.NavigationDefn, 'disableThrottling'|'disableStorageReset'|'blockedUrlPatterns'> & {url: string}} navigation
+ * @param {{disableThrottling: boolean, blockedUrlPatterns?: string[]}} options
  */
-async function prepareNetworkForNavigation(session, settings, navigation) {
-  const status = {msg: 'Preparing network conditions', id: `lh:gather:prepareNetworkForNavigation`};
+async function prepareThrottlingAndNetwork(session, settings, options) {
+  const status = {msg: 'Preparing network conditions', id: `lh:gather:prepareThrottlingAndNetwork`};
   log.time(status);
 
-  if (navigation.disableThrottling) await emulation.clearThrottling(session);
+  if (options.disableThrottling) await emulation.clearThrottling(session);
   else await emulation.throttle(session, settings);
 
   // Set request blocking before any network activity.
-  // No "clearing" is done at the end of the navigation since Network.setBlockedURLs([]) will unset all if
-  // neccessary at the beginning of the next navigation.
-  const blockedUrls = (navigation.blockedUrlPatterns || []).concat(
+  // No "clearing" is done at the end of the recording since Network.setBlockedURLs([]) will unset all if
+  // neccessary at the beginning of the next section.
+  const blockedUrls = (options.blockedUrlPatterns || []).concat(
     settings.blockedUrlPatterns || []
   );
   await session.sendCommand('Network.setBlockedURLs', {urls: blockedUrls});
@@ -118,16 +118,14 @@ async function prepareNetworkForNavigation(session, settings, navigation) {
 }
 
 /**
- * Prepares a target to be analyzed in navigation mode by enabling protocol domains, emulation, and new document
- * handlers for global APIs or error handling.
- *
- * This method should be used in combination with `prepareTargetForIndividualNavigation` before a specific navigation occurs.
+ * Prepares a target to be analyzed by setting up device emulation (screen/UA, not throttling) and
+ * async stack traces for network initiators.
  *
  * @param {LH.Gatherer.FRTransitionalDriver} driver
  * @param {LH.Config.Settings} settings
  */
-async function prepareTargetForNavigationMode(driver, settings) {
-  // Enable network domain here so future calls to `emulate()` don't clear cache (#12631)
+async function prepareDeviceEmulationAndAsyncStacks(driver, settings) {
+  // Enable network domain here so future calls to `emulate()` don't clear cache (https://github.com/GoogleChrome/lighthouse/issues/12631)
   await driver.defaultSession.sendCommand('Network.enable');
 
   // Emulate our target device screen and user agent.
@@ -135,6 +133,33 @@ async function prepareTargetForNavigationMode(driver, settings) {
 
   // Enable better stacks on network requests.
   await enableAsyncStacks(driver.defaultSession);
+}
+
+/**
+ * Prepares a target to be analyzed in timespan mode by enabling protocol domains, emulation, and throttling.
+ *
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ * @param {LH.Config.Settings} settings
+ */
+async function prepareTargetForTimespanMode(driver, settings) {
+  await prepareDeviceEmulationAndAsyncStacks(driver, settings);
+  await prepareThrottlingAndNetwork(driver.defaultSession, settings, {
+    disableThrottling: false,
+    blockedUrlPatterns: undefined,
+  });
+}
+
+/**
+ * Prepares a target to be analyzed in navigation mode by enabling protocol domains, emulation, and new document
+ * handlers for global APIs or error handling.
+ *
+ * This method should be used in combination with `prepareTargetForIndividualNavigation` before a specific navigation occurs.
+ *
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ * @param {LH.Config.Settings} settings
+ */
+async function prepareTargetForNavigationMode(driver, settings) {
+  await prepareDeviceEmulationAndAsyncStacks(driver, settings);
 
   // Automatically handle any JavaScript dialogs to prevent a hung renderer.
   await dismissJavaScriptDialogs(driver.defaultSession);
@@ -168,13 +193,14 @@ async function prepareTargetForIndividualNavigation(session, settings, navigatio
     warnings.push(...storageWarnings);
   }
 
-  await prepareNetworkForNavigation(session, settings, navigation);
+  await prepareThrottlingAndNetwork(session, settings, navigation);
 
   return {warnings};
 }
 
 module.exports = {
-  prepareNetworkForNavigation,
+  prepareThrottlingAndNetwork,
+  prepareTargetForTimespanMode,
   prepareTargetForNavigationMode,
   prepareTargetForIndividualNavigation,
 };

package/lighthouse-core/gather/driver/target-manager.js

@@ -0,0 +1,125 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+'use strict';
+
+/**
+  * @fileoverview This class tracks multiple targets (the page itself and its OOPIFs) and allows consumers to
+  * listen for protocol events before each target is resumed.
+  */
+
+const log = require('lighthouse-logger');
+
+/** @typedef {{target: LH.Crdp.Target.TargetInfo, session: LH.Gatherer.FRProtocolSession}} TargetWithSession */
+
+class TargetManager {
+  /** @param {LH.Gatherer.FRProtocolSession} session */
+  constructor(session) {
+    this._enabled = false;
+    this._session = session;
+    /** @type {Array<(targetWithSession: TargetWithSession) => Promise<void>|void>} */
+    this._listeners = [];
+
+    this._onSessionAttached = this._onSessionAttached.bind(this);
+
+    /** @type {Map<string, TargetWithSession>} */
+    this._targets = new Map();
+
+    /** @param {LH.Crdp.Page.FrameNavigatedEvent} event */
+    this._onFrameNavigated = async event => {
+      // Child frames are handled in `_onSessionAttached`.
+      if (event.frame.parentId) return;
+
+      // It's not entirely clear when this is necessary, but when the page switches processes on
+      // navigating from about:blank to the `requestedUrl`, resetting `setAutoAttach` has been
+      // necessary in the past.
+      await this._session.sendCommand('Target.setAutoAttach', {
+        autoAttach: true,
+        flatten: true,
+        waitForDebuggerOnStart: true,
+      });
+    };
+  }
+
+  /**
+   * @param {LH.Gatherer.FRProtocolSession} session
+   */
+  async _onSessionAttached(session) {
+    try {
+      const target = await session.sendCommand('Target.getTargetInfo').catch(() => null);
+      const targetType = target && target.targetInfo && target.targetInfo.type;
+      const hasValidTargetType = targetType === 'page' || targetType === 'iframe';
+      if (!target || !hasValidTargetType) return;
+
+      const targetId = target.targetInfo.targetId;
+      session.setTargetInfo(target.targetInfo);
+      if (this._targets.has(targetId)) return;
+
+      const targetName = target.targetInfo.url || target.targetInfo.targetId;
+      log.verbose('target-manager', `target ${targetName} attached`);
+
+      const targetWithSession = {target: target.targetInfo, session};
+      this._targets.set(targetId, targetWithSession);
+      for (const listener of this._listeners) await listener(targetWithSession);
+
+      await session.sendCommand('Target.setAutoAttach', {
+        autoAttach: true,
+        flatten: true,
+        waitForDebuggerOnStart: true,
+      });
+    } catch (err) {
+      // Sometimes targets can be closed before we even have a chance to listen to their network activity.
+      if (/Target closed/.test(err.message)) return;
+
+      throw err;
+    } finally {
+      // Resume the target if it was paused, but if it's unnecessary, we don't care about the error.
+      await session.sendCommand('Runtime.runIfWaitingForDebugger').catch(() => {});
+    }
+  }
+
+  /**
+   * @return {Promise<void>}
+   */
+  async enable() {
+    if (this._enabled) return;
+
+    this._enabled = true;
+    this._targets = new Map();
+
+    this._session.on('Page.frameNavigated', this._onFrameNavigated);
+    this._session.addSessionAttachedListener(this._onSessionAttached);
+
+    await this._session.sendCommand('Page.enable');
+    await this._onSessionAttached(this._session);
+  }
+
+  /**
+   * @return {Promise<void>}
+   */
+  async disable() {
+    this._session.off('Page.frameNavigated', this._onFrameNavigated);
+    this._session.removeSessionAttachedListener(this._onSessionAttached);
+
+    this._enabled = false;
+    this._targets = new Map();
+  }
+
+  /**
+   * @param {(targetWithSession: TargetWithSession) => Promise<void>|void} listener
+   */
+  addTargetAttachedListener(listener) {
+    this._listeners.push(listener);
+  }
+
+  /**
+   * @param {(targetWithSession: TargetWithSession) => Promise<void>|void} listener
+   */
+  removeTargetAttachedListener(listener) {
+    this._listeners = this._listeners.filter(entry => entry !== listener);
+  }
+}
+
+module.exports = TargetManager;

package/lighthouse-core/gather/driver.js

@@ -127,6 +127,11 @@ class Driver {
     return this._connection.disconnect();
   }
 
+  /** @return {Promise<void>} */
+  dispose() {
+    return this.disconnect();
+  }
+
   /**
    * Get the browser WebSocket endpoint for devtools protocol clients like Puppeteer.
    * Only works with WebSocket connection, not extension or devtools.
@@ -198,6 +203,21 @@ class Driver {
     this._connection.off('protocolevent', callback);
   }
 
+  /** @param {LH.Crdp.Target.TargetInfo} targetInfo */
+  setTargetInfo(targetInfo) { // eslint-disable-line no-unused-vars
+    // OOPIF handling in legacy driver is implicit.
+  }
+
+  /** @param {(session: LH.Gatherer.FRProtocolSession) => void} callback */
+  addSessionAttachedListener(callback) { // eslint-disable-line no-unused-vars
+    // OOPIF handling in legacy driver is implicit.
+  }
+
+  /** @param {(session: LH.Gatherer.FRProtocolSession) => void} callback */
+  removeSessionAttachedListener(callback) { // eslint-disable-line no-unused-vars
+    // OOPIF handling in legacy driver is implicit.
+  }
+
   /**
    * Debounce enabling or disabling domains to prevent driver users from
    * stomping on each other. Maintains an internal count of the times a domain

package/lighthouse-core/gather/fetcher.js

@@ -114,7 +114,7 @@ class Fetcher {
    * @param {{timeout: number}=} options timeout is in ms
    * @return {Promise<FetchResponse>}
    */
-  async fetchResource(url, options = {timeout: 500}) {
+  async fetchResource(url, options = {timeout: 2_000}) {
     if (!this._enabled) {
       throw new Error('Must call `enable` before using fetchResource');
     }
@@ -131,7 +131,7 @@ class Fetcher {
    * @param {{timeout: number}=} options,
    * @return {Promise<string>}
    */
-  async _readIOStream(handle, options = {timeout: 500}) {
+  async _readIOStream(handle, options = {timeout: 2_000}) {
     const startTime = Date.now();
 
     let ioResponse;

package/lighthouse-core/gather/gather-runner.js

@@ -155,7 +155,6 @@ class GatherRunner {
     const session = driver.defaultSession;
 
     // Assert no service workers are still installed, so we test that they would actually be installed for a new user.
-    // TODO(FR-COMPAT): re-evaluate the necessity of this check
     await GatherRunner.assertNoSameOriginServiceWorkerClients(session, options.requestedUrl);
 
     await prepare.prepareTargetForNavigationMode(driver, options.settings);
@@ -407,6 +406,7 @@ class GatherRunner {
       traces: {},
       devtoolsLogs: {},
       settings: options.settings,
+      GatherContext: {gatherMode: 'navigation'},
       URL: {requestedUrl: options.requestedUrl, finalUrl: options.requestedUrl},
       Timing: [],
       PageLoadError: null,

package/lighthouse-core/gather/gatherers/css-usage.js

@@ -20,7 +20,6 @@ class CSSUsage extends FRGatherer {
     /** @param {LH.Crdp.CSS.StyleSheetRemovedEvent} sheet */
     this._onStylesheetRemoved = sheet => {
       // We can't fetch the content of removed stylesheets, so we ignore them completely.
-      // TODO(FR-COMPAT): Refactor use of CSSUsage artifact to not *always* rely on the content of stylesheets.
       const styleSheetId = sheet.styleSheetId;
       this._stylesheets = this._stylesheets.filter(s => s.header.styleSheetId !== styleSheetId);
     };
@@ -84,7 +83,6 @@ class CSSUsage extends FRGatherer {
     const session = context.driver.defaultSession;
     const executionContext = context.driver.executionContext;
 
-    // TODO(FR-COMPAT): Do this only for snapshot once legacy runner is deprecated.
     if (context.gatherMode !== 'timespan') {
       await this.startCSSUsageTracking(context);
 

package/lighthouse-core/gather/gatherers/devtools-log.js

@@ -11,6 +11,7 @@
  * This protocol log can be used to recreate the network records using lib/network-recorder.js.
  */
 
+const NetworkMonitor = require('../driver/network-monitor.js');
 const MessageLog = require('../devtools-log.js');
 const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
 
@@ -26,6 +27,9 @@ class DevtoolsLog extends FRGatherer {
   constructor() {
     super();
 
+    /** @type {NetworkMonitor|undefined} */
+    this._networkMonitor = undefined;
+
     this._messageLog = new MessageLog(/^(Page|Network)\./);
 
     /** @param {LH.Protocol.RawEventMessage} e */
@@ -38,19 +42,17 @@ class DevtoolsLog extends FRGatherer {
   async startSensitiveInstrumentation({driver}) {
     this._messageLog.reset();
     this._messageLog.beginRecording();
-    driver.defaultSession.addProtocolMessageListener(this._onProtocolMessage);
 
-    // TODO(FR-COMPAT): use a dedicated session for these
-    await driver.defaultSession.sendCommand('Page.enable');
-    await driver.defaultSession.sendCommand('Network.enable');
+    this._networkMonitor = new NetworkMonitor(driver.defaultSession);
+    this._networkMonitor.on('protocolmessage', this._onProtocolMessage);
+    this._networkMonitor.enable();
   }
 
-  /**
-   * @param {LH.Gatherer.FRTransitionalContext} passContext
-   */
-  async stopSensitiveInstrumentation({driver}) {
+  async stopSensitiveInstrumentation() {
+    if (!this._networkMonitor) return;
     this._messageLog.endRecording();
-    driver.defaultSession.removeProtocolMessageListener(this._onProtocolMessage);
+    this._networkMonitor.disable();
+    this._networkMonitor.off('protocolmessage', this._onProtocolMessage);
   }
 
   /**

package/lighthouse-core/gather/gatherers/js-usage.js

@@ -134,7 +134,6 @@ class JsUsage extends FRGatherer {
       usageByUrl[url] = scripts;
     }
 
-    // TODO(FR-COMPAT): Enable this logic for legacy and navigation or make a separate artifact for url/scriptId mappings.
     if (context.gatherMode !== 'navigation') {
       this._addMissingScriptIds(usageByUrl);
     }

package/lighthouse-core/gather/gatherers/script-elements.js

@@ -12,7 +12,6 @@ const NetworkRequest = require('../../lib/network-request.js');
 const pageFunctions = require('../../lib/page-functions.js');
 const {fetchResponseBodyFromCache} = require('../driver/network.js');
 const DevtoolsLog = require('./devtools-log.js');
-const HostFormFactor = require('./host-form-factor.js');
 
 /* global getNodeDetails */
 
@@ -67,10 +66,10 @@ async function runInSeriesOrParallel(values, promiseMapper, runInSeries) {
  * @fileoverview Gets JavaScript file contents.
  */
 class ScriptElements extends FRGatherer {
-  /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'|'HostFormFactor'>} */
+  /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
   meta = {
     supportedModes: ['timespan', 'navigation'],
-    dependencies: {DevtoolsLog: DevtoolsLog.symbol, HostFormFactor: HostFormFactor.symbol},
+    dependencies: {DevtoolsLog: DevtoolsLog.symbol},
   }
 
   /**
@@ -138,11 +137,11 @@ class ScriptElements extends FRGatherer {
   }
 
   /**
-   * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'|'HostFormFactor'>} context
+   * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
    */
   async getArtifact(context) {
     const devtoolsLog = context.dependencies.DevtoolsLog;
-    const formFactor = context.dependencies.HostFormFactor;
+    const formFactor = context.baseArtifacts.HostFormFactor;
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
     return this._getArtifact(context, networkRecords, formFactor);
   }

package/lighthouse-core/gather/gatherers/seo/robots-txt.js

@@ -20,8 +20,8 @@ async function getRobotsTxtContent() {
 
     const content = await response.text();
     return {status: response.status, content};
-  } catch (_) {
-    return {status: null, content: null};
+  } catch (err) {
+    return {status: null, content: null, errorMessage: err.message};
   }
 }
 /* c8 ignore stop */
@@ -49,7 +49,7 @@ class RobotsTxt extends FRGatherer {
     const robotsUrl = new URL('/robots.txt', passContext.url).href;
     await passContext.driver.fetcher.enable();
     return passContext.driver.fetcher.fetchResource(robotsUrl)
-      .catch(() => ({status: null, content: null}));
+      .catch(err => ({status: null, content: null, errorMessage: err.message}));
   }
 }
 

package/lighthouse-core/gather/gatherers/trace.js

@@ -60,7 +60,6 @@ class Trace extends FRGatherer {
       // A bug introduced in M92 causes these categories to crash targets on Linux.
       // See https://github.com/GoogleChrome/lighthouse/issues/12835 for full investigation.
       // 'disabled-by-default-v8.cpu_profiler',
-      // 'disabled-by-default-v8.cpu_profiler.hires',
     ];
   }
 
@@ -102,12 +101,12 @@ class Trace extends FRGatherer {
   /**
    * @param {LH.Gatherer.FRTransitionalContext} passContext
    */
-  async startSensitiveInstrumentation({driver, gatherMode}) {
-    // TODO(FR-COMPAT): read additional trace categories from overall settings?
-    // TODO(FR-COMPAT): check if CSS/DOM domains have been enabled in another session and warn?
+  async startSensitiveInstrumentation({driver, gatherMode, settings}) {
+    const traceCategories = Trace.getDefaultTraceCategories()
+      .concat(settings.additionalTraceCategories || []);
     await driver.defaultSession.sendCommand('Page.enable');
     await driver.defaultSession.sendCommand('Tracing.start', {
-      categories: Trace.getDefaultTraceCategories().join(','),
+      categories: traceCategories.join(','),
       options: 'sampling-frequency=10000', // 1000 is default and too slow.
     });
 

package/lighthouse-core/index.js

@@ -70,6 +70,10 @@ lighthouse.getAuditList = Runner.getAuditList;
 lighthouse.traceCategories = require('./gather/driver.js').traceCategories;
 lighthouse.Audit = require('./audits/audit.js');
 lighthouse.Gatherer = require('./gather/gatherers/gatherer.js');
+
+// Explicit type reference (hidden by makeComputedArtifact) for d.ts export.
+// TODO(esmodules): should be a workaround for module.export and can be removed when in esm.
+/** @type {typeof import('./computed/network-records.js')} */
 lighthouse.NetworkRecords = require('./computed/network-records.js');
 
 module.exports = lighthouse;

package/lighthouse-core/lib/emulation.js

@@ -47,7 +47,6 @@ async function emulate(session, settings) {
  * @return {Promise<void>}
  */
 async function throttle(session, settings) {
-  // TODO(FR-COMPAT): reconsider if this should be resetting anything
   if (settings.throttlingMethod !== 'devtools') return clearNetworkThrottling(session);
 
   await Promise.all([

package/lighthouse-core/lib/i18n/locales/en-US.json

@@ -554,6 +554,12 @@
   "lighthouse-core/audits/byte-efficiency/uses-responsive-images-snapshot.js | columnDisplayedDimensions": {
     "message": "Displayed dimensions"
   },
+  "lighthouse-core/audits/byte-efficiency/uses-responsive-images-snapshot.js | failureTitle": {
+    "message": "Images were larger than their displayed size"
+  },
+  "lighthouse-core/audits/byte-efficiency/uses-responsive-images-snapshot.js | title": {
+    "message": "Images were appropriate for their displayed size"
+  },
   "lighthouse-core/audits/byte-efficiency/uses-responsive-images.js | description": {
     "message": "Serve images that are appropriately-sized to save cellular data and improve load time. [Learn more](https://web.dev/uses-responsive-images/)."
   },

package/lighthouse-core/lib/i18n/locales/en-XL.json

@@ -554,6 +554,12 @@
   "lighthouse-core/audits/byte-efficiency/uses-responsive-images-snapshot.js | columnDisplayedDimensions": {
     "message": "D̂íŝṕl̂áŷéd̂ d́îḿêńŝíôńŝ"
   },
+  "lighthouse-core/audits/byte-efficiency/uses-responsive-images-snapshot.js | failureTitle": {
+    "message": "Îḿâǵêś ŵér̂é l̂ár̂ǵêŕ t̂h́âń t̂h́êír̂ d́îśp̂ĺâýêd́ ŝíẑé"
+  },
+  "lighthouse-core/audits/byte-efficiency/uses-responsive-images-snapshot.js | title": {
+    "message": "Îḿâǵêś ŵér̂é âṕp̂ŕôṕr̂íât́ê f́ôŕ t̂h́êír̂ d́îśp̂ĺâýêd́ ŝíẑé"
+  },
   "lighthouse-core/audits/byte-efficiency/uses-responsive-images.js | description": {
     "message": "Ŝér̂v́ê ím̂áĝéŝ t́ĥát̂ ár̂é âṕp̂ŕôṕr̂íât́êĺŷ-śîźêd́ t̂ó ŝáv̂é ĉél̂ĺûĺâŕ d̂át̂á âńd̂ ím̂ṕr̂óv̂é l̂óâd́ t̂ím̂é. [L̂éâŕn̂ ḿôŕê](https://web.dev/uses-responsive-images/)."
   },

package/lighthouse-core/lib/network-recorder.js

@@ -5,6 +5,7 @@
  */
 'use strict';
 
+const log = require('lighthouse-logger');
 const NetworkRequest = require('./network-request.js');
 const EventEmitter = require('events').EventEmitter;
 
@@ -88,6 +89,7 @@ class NetworkRecorder extends EventEmitter {
       request.onRequestWillBeSent(data);
       request.sessionId = event.sessionId;
       this.onRequestStarted(request);
+      log.verbose('network', `request will be sent to ${request.url}`);
       return;
     }
 
@@ -108,6 +110,7 @@ class NetworkRecorder extends EventEmitter {
 
     redirectedRequest.onRequestWillBeSent(modifiedData);
     originalRequest.onRedirectResponse(data);
+    log.verbose('network', `${originalRequest.url} redirected to ${redirectedRequest.url}`);
 
     originalRequest.redirectDestination = redirectedRequest;
     redirectedRequest.redirectSource = originalRequest;
@@ -124,6 +127,7 @@ class NetworkRecorder extends EventEmitter {
     const data = event.params;
     const request = this._findRealRequestAndSetSession(data.requestId, event.sessionId);
     if (!request) return;
+    log.verbose('network', `${request.url} served from cache`);
     request.onRequestServedFromCache();
   }
 
@@ -134,6 +138,7 @@ class NetworkRecorder extends EventEmitter {
     const data = event.params;
     const request = this._findRealRequestAndSetSession(data.requestId, event.sessionId);
     if (!request) return;
+    log.verbose('network', `${request.url} response received`);
     request.onResponseReceived(data);
   }
 
@@ -144,6 +149,7 @@ class NetworkRecorder extends EventEmitter {
     const data = event.params;
     const request = this._findRealRequestAndSetSession(data.requestId, event.sessionId);
     if (!request) return;
+    log.verbose('network', `${request.url} data received`);
     request.onDataReceived(data);
   }
 
@@ -154,6 +160,7 @@ class NetworkRecorder extends EventEmitter {
     const data = event.params;
     const request = this._findRealRequestAndSetSession(data.requestId, event.sessionId);
     if (!request) return;
+    log.verbose('network', `${request.url} loading finished`);
     request.onLoadingFinished(data);
     this.onRequestFinished(request);
   }
@@ -165,6 +172,7 @@ class NetworkRecorder extends EventEmitter {
     const data = event.params;
     const request = this._findRealRequestAndSetSession(data.requestId, event.sessionId);
     if (!request) return;
+    log.verbose('network', `${request.url} loading failed`);
     request.onLoadingFailed(data);
     this.onRequestFinished(request);
   }

package/lighthouse-core/lib/proto-preprocessor.js

@@ -16,10 +16,10 @@ const fs = require('fs');
  */
 
 /**
-  * Transform an LHR into a proto-friendly, mostly-compatible LHR.
-  * @param {LH.Result} lhr
-  * @return {LH.Result}
-  */
+ * Transform an LHR into a proto-friendly, mostly-compatible LHR.
+ * @param {LH.Result} lhr
+ * @return {LH.Result}
+ */
 function processForProto(lhr) {
   /** @type {LH.Result} */
   const reportJson = JSON.parse(JSON.stringify(lhr));
@@ -68,13 +68,8 @@ function processForProto(lhr) {
     });
   }
 
-  // Drop the i18n icuMessagePaths. Painful in proto, and low priority to expose currently.
-  if (reportJson.i18n && reportJson.i18n.icuMessagePaths) {
-    delete reportJson.i18n.icuMessagePaths;
-  }
-
-  // Remove any found empty strings, as they are dropped after round-tripping anyway
   /**
+   * Remove any found empty strings, as they are dropped after round-tripping anyway
    * @param {any} obj
    */
   function removeStrings(obj) {

package/lighthouse-core/runner.js

@@ -132,9 +132,7 @@ class Runner {
 
       /** @type {LH.RawIcu<LH.Result>} */
       const i18nLhr = {
-        // TODO(FR-COMPAT): Make GatherContext a true base artifact.
-        // If GatherContext is not collected, then we are in a non-default pass of the legacy runner.
-        gatherMode: artifacts.GatherContext ? artifacts.GatherContext.gatherMode : 'navigation',
+        gatherMode: artifacts.GatherContext.gatherMode,
         userAgent: artifacts.HostUserAgent,
         environment: {
           networkUserAgent: artifacts.NetworkUserAgent,