lighthouse 9.6.7 → 10.0.0

package/core/gather/driver/network-monitor.js

@@ -0,0 +1,260 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview This class wires up the procotol to a network recorder and provides overall
+ * status inspection state.
+ */
+
+import {EventEmitter} from 'events';
+
+import log from 'lighthouse-logger';
+
+import {NetworkRecorder} from '../../lib/network-recorder.js';
+import {NetworkRequest} from '../../lib/network-request.js';
+import UrlUtils from '../../lib/url-utils.js';
+
+/** @typedef {import('../../lib/network-recorder.js').NetworkRecorderEventMap} NetworkRecorderEventMap */
+/** @typedef {'network-2-idle'|'network-critical-idle'|'networkidle'|'networkbusy'|'network-critical-busy'|'network-2-busy'} NetworkMonitorEvent_ */
+/** @typedef {Record<NetworkMonitorEvent_, []> & NetworkRecorderEventMap} NetworkMonitorEventMap */
+/** @typedef {keyof NetworkMonitorEventMap} NetworkMonitorEvent */
+/** @typedef {LH.Protocol.StrictEventEmitterClass<NetworkMonitorEventMap>} NetworkMonitorEmitter */
+const NetworkMonitorEventEmitter = /** @type {NetworkMonitorEmitter} */ (EventEmitter);
+
+class NetworkMonitor extends NetworkMonitorEventEmitter {
+  /** @type {NetworkRecorder|undefined} */
+  _networkRecorder = undefined;
+  /** @type {Array<LH.Crdp.Page.Frame>} */
+  _frameNavigations = [];
+
+  // TODO(FR-COMPAT): switch to real TargetManager when legacy removed.
+  /** @param {LH.Gatherer.FRTransitionalDriver['targetManager']} targetManager */
+  constructor(targetManager) {
+    super();
+
+    /** @type {LH.Gatherer.FRTransitionalDriver['targetManager']} */
+    this._targetManager = targetManager;
+
+    /** @type {LH.Gatherer.FRProtocolSession} */
+    this._session = targetManager.rootSession();
+
+    /** @param {LH.Crdp.Page.FrameNavigatedEvent} event */
+    this._onFrameNavigated = event => this._frameNavigations.push(event.frame);
+
+    /** @param {LH.Protocol.RawEventMessage} event */
+    this._onProtocolMessage = event => {
+      if (!this._networkRecorder) return;
+      this._networkRecorder.dispatch(event);
+    };
+  }
+
+  /**
+   * @return {Promise<void>}
+   */
+  async enable() {
+    if (this._networkRecorder) return;
+
+    this._frameNavigations = [];
+    this._networkRecorder = new NetworkRecorder();
+
+    /**
+     * Reemit the same network recorder events.
+     * @param {keyof NetworkRecorderEventMap} event
+     * @return {(r: NetworkRequest) => void}
+     */
+    const reEmit = event => r => {
+      this.emit(event, r);
+      this._emitNetworkStatus();
+    };
+
+    this._networkRecorder.on('requeststarted', reEmit('requeststarted'));
+    this._networkRecorder.on('requestfinished', reEmit('requestfinished'));
+
+    this._session.on('Page.frameNavigated', this._onFrameNavigated);
+    this._targetManager.on('protocolevent', this._onProtocolMessage);
+  }
+
+  /**
+   * @return {Promise<void>}
+   */
+  async disable() {
+    if (!this._networkRecorder) return;
+
+    this._session.off('Page.frameNavigated', this._onFrameNavigated);
+    this._targetManager.off('protocolevent', this._onProtocolMessage);
+
+    this._frameNavigations = [];
+    this._networkRecorder = undefined;
+  }
+
+  /** @return {Promise<{requestedUrl?: string, mainDocumentUrl?: string}>} */
+  async getNavigationUrls() {
+    const frameNavigations = this._frameNavigations;
+    if (!frameNavigations.length) return {};
+
+    const frameTreeResponse = await this._session.sendCommand('Page.getFrameTree');
+    const mainFrameId = frameTreeResponse.frameTree.frame.id;
+    const mainFrameNavigations = frameNavigations.filter(frame => frame.id === mainFrameId);
+    if (!mainFrameNavigations.length) log.warn('NetworkMonitor', 'No detected navigations');
+
+    // The requested URL is the initiator request for the first frame navigation.
+    /** @type {string|undefined} */
+    let requestedUrl = mainFrameNavigations[0]?.url;
+    if (this._networkRecorder) {
+      const records = this._networkRecorder.getRawRecords();
+
+      let initialUrlRequest = records.find(record => record.url === requestedUrl);
+      while (initialUrlRequest?.redirectSource) {
+        initialUrlRequest = initialUrlRequest.redirectSource;
+        requestedUrl = initialUrlRequest.url;
+      }
+    }
+
+    return {
+      requestedUrl,
+      mainDocumentUrl: mainFrameNavigations[mainFrameNavigations.length - 1]?.url,
+    };
+  }
+
+  /**
+   * @return {Array<NetworkRequest>}
+   */
+  getInflightRequests() {
+    if (!this._networkRecorder) return [];
+    return this._networkRecorder.getRawRecords().filter(request => !request.finished);
+  }
+
+  /**
+   * Returns whether the network is completely idle (i.e. there are 0 inflight network requests).
+   */
+  isIdle() {
+    return this._isActiveIdlePeriod(0);
+  }
+
+  /**
+   * Returns whether any important resources for the page are in progress.
+   * Above-the-fold images and XHRs should be included.
+   * Tracking pixels, low priority images, and cross frame requests should be excluded.
+   * @return {boolean}
+   */
+  isCriticalIdle() {
+    if (!this._networkRecorder) return false;
+    const requests = this._networkRecorder.getRawRecords();
+    const rootFrameRequest = requests.find(r => r.resourceType === 'Document');
+    const rootFrameId = rootFrameRequest?.frameId;
+
+    return this._isActiveIdlePeriod(
+      0,
+      request =>
+        request.frameId === rootFrameId &&
+        (request.priority === 'VeryHigh' || request.priority === 'High')
+    );
+  }
+
+  /**
+   * Returns whether the network is semi-idle (i.e. there are 2 or fewer inflight network requests).
+   */
+  is2Idle() {
+    return this._isActiveIdlePeriod(2);
+  }
+
+  /**
+   * Returns whether the number of currently inflight requests is less than or
+   * equal to the number of allowed concurrent requests.
+   * @param {number} allowedRequests
+   * @param {(request: NetworkRequest) => boolean} [requestFilter]
+   * @return {boolean}
+   */
+  _isActiveIdlePeriod(allowedRequests, requestFilter) {
+    if (!this._networkRecorder) return false;
+    const requests = this._networkRecorder.getRawRecords();
+    let inflightRequests = 0;
+
+    for (let i = 0; i < requests.length; i++) {
+      const request = requests[i];
+      if (request.finished) continue;
+      if (requestFilter && !requestFilter(request)) continue;
+      if (NetworkRequest.isNonNetworkRequest(request)) continue;
+      inflightRequests++;
+    }
+
+    return inflightRequests <= allowedRequests;
+  }
+
+  /**
+   * Emits the appropriate network status event.
+   */
+  _emitNetworkStatus() {
+    const zeroQuiet = this.isIdle();
+    const twoQuiet = this.is2Idle();
+    const criticalQuiet = this.isCriticalIdle();
+
+    this.emit(zeroQuiet ? 'networkidle' : 'networkbusy');
+    this.emit(twoQuiet ? 'network-2-idle' : 'network-2-busy');
+    this.emit(criticalQuiet ? 'network-critical-idle' : 'network-critical-busy');
+
+    if (twoQuiet && zeroQuiet) log.verbose('NetworkRecorder', 'network fully-quiet');
+    else if (twoQuiet && !zeroQuiet) log.verbose('NetworkRecorder', 'network semi-quiet');
+    else log.verbose('NetworkRecorder', 'network busy');
+  }
+
+  /**
+   * Finds all time periods where the number of inflight requests is less than or equal to the
+   * number of allowed concurrent requests.
+   * @param {Array<LH.Artifacts.NetworkRequest>} requests
+   * @param {number} allowedConcurrentRequests
+   * @param {number=} endTime
+   * @return {Array<{start: number, end: number}>}
+   */
+  static findNetworkQuietPeriods(requests, allowedConcurrentRequests, endTime = Infinity) {
+    // First collect the timestamps of when requests start and end
+    /** @type {Array<{time: number, isStart: boolean}>} */
+    let timeBoundaries = [];
+    requests.forEach(request => {
+      if (UrlUtils.isNonNetworkProtocol(request.protocol)) return;
+      if (request.protocol === 'ws' || request.protocol === 'wss') return;
+
+      // convert the network timestamp to ms
+      timeBoundaries.push({time: request.networkRequestTime * 1000, isStart: true});
+      if (request.finished) {
+        timeBoundaries.push({time: request.networkEndTime * 1000, isStart: false});
+      }
+    });
+
+    timeBoundaries = timeBoundaries
+      .filter(boundary => boundary.time <= endTime)
+      .sort((a, b) => a.time - b.time);
+
+    let numInflightRequests = 0;
+    let quietPeriodStart = 0;
+    /** @type {Array<{start: number, end: number}>} */
+    const quietPeriods = [];
+    timeBoundaries.forEach(boundary => {
+      if (boundary.isStart) {
+        // we've just started a new request. are we exiting a quiet period?
+        if (numInflightRequests === allowedConcurrentRequests) {
+          quietPeriods.push({start: quietPeriodStart, end: boundary.time});
+        }
+        numInflightRequests++;
+      } else {
+        numInflightRequests--;
+        // we've just completed a request. are we entering a quiet period?
+        if (numInflightRequests === allowedConcurrentRequests) {
+          quietPeriodStart = boundary.time;
+        }
+      }
+    });
+
+    // Check we ended in a quiet period
+    if (numInflightRequests <= allowedConcurrentRequests) {
+      quietPeriods.push({start: quietPeriodStart, end: endTime});
+    }
+
+    return quietPeriods.filter(period => period.start !== period.end);
+  }
+}
+
+export {NetworkMonitor};

package/core/gather/driver/network.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Return the body of the response with the given ID. Rejects if getting the
+ * body times out.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {string} requestId
+ * @param {number} [timeout]
+ * @return {Promise<string>}
+ */
+export function fetchResponseBodyFromCache(session: LH.Gatherer.FRProtocolSession, requestId: string, timeout?: number | undefined): Promise<string>;
+//# sourceMappingURL=network.d.ts.map

package/core/gather/driver/network.js

@@ -0,0 +1,27 @@
+/**
+ * @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.
+ */
+
+import {NetworkRequest} from '../../lib/network-request.js';
+
+/**
+ * Return the body of the response with the given ID. Rejects if getting the
+ * body times out.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {string} requestId
+ * @param {number} [timeout]
+ * @return {Promise<string>}
+ */
+async function fetchResponseBodyFromCache(session, requestId, timeout = 1000) {
+  requestId = NetworkRequest.getRequestIdForBackend(requestId);
+
+  // Encoding issues may lead to hanging getResponseBody calls: https://github.com/GoogleChrome/lighthouse/pull/4718
+  // session.sendCommand will handle timeout after 1s.
+  session.setNextProtocolTimeout(timeout);
+  const result = await session.sendCommand('Network.getResponseBody', {requestId});
+  return result.body;
+}
+
+export {fetchResponseBodyFromCache};

package/core/gather/driver/prepare.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Prepares a target for observational analysis by setting throttling and network headers/blocked patterns.
+ *
+ * This method assumes `prepareTargetForNavigationMode` or `prepareTargetForTimespanMode` has already been invoked.
+ *
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Config.Settings} settings
+ * @param {{disableThrottling: boolean, blockedUrlPatterns?: string[]}} options
+ */
+export function prepareThrottlingAndNetwork(session: LH.Gatherer.FRProtocolSession, settings: LH.Config.Settings, options: {
+    disableThrottling: boolean;
+    blockedUrlPatterns?: string[];
+}): Promise<void>;
+/**
+ * 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
+ */
+export function prepareTargetForTimespanMode(driver: LH.Gatherer.FRTransitionalDriver, settings: LH.Config.Settings): Promise<void>;
+/**
+ * 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
+ */
+export function prepareTargetForNavigationMode(driver: LH.Gatherer.FRTransitionalDriver, settings: LH.Config.Settings): Promise<void>;
+/**
+ * Prepares a target for a particular navigation by resetting storage and setting network.
+ *
+ * This method assumes `prepareTargetForNavigationMode` has already been invoked.
+ *
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Config.Settings} settings
+ * @param {Pick<LH.Config.NavigationDefn, 'disableThrottling'|'disableStorageReset'|'blockedUrlPatterns'> & {requestor: LH.NavigationRequestor}} navigation
+ * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
+ */
+export function prepareTargetForIndividualNavigation(session: LH.Gatherer.FRProtocolSession, settings: LH.Config.Settings, navigation: Pick<import("../../../types/config.js").default.NavigationDefn, "blockedUrlPatterns" | "disableStorageReset" | "disableThrottling"> & {
+    requestor: LH.NavigationRequestor;
+}): Promise<{
+    warnings: Array<LH.IcuMessage>;
+}>;
+/**
+ * Enables `Debugger` domain to receive async stacktrace information on network request initiators.
+ * This is critical for tracking attribution of tasks and performance simulation accuracy.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ */
+export function enableAsyncStacks(session: LH.Gatherer.FRProtocolSession): Promise<() => Promise<void>>;
+//# sourceMappingURL=prepare.d.ts.map

package/core/gather/driver/prepare.js

@@ -0,0 +1,244 @@
+/**
+ * @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.
+ */
+
+import log from 'lighthouse-logger';
+
+import * as storage from './storage.js';
+import * as emulation from '../../lib/emulation.js';
+import {pageFunctions} from '../../lib/page-functions.js';
+
+/**
+ * Enables `Debugger` domain to receive async stacktrace information on network request initiators.
+ * This is critical for tracking attribution of tasks and performance simulation accuracy.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ */
+async function enableAsyncStacks(session) {
+  const enable = async () => {
+    await session.sendCommand('Debugger.enable');
+    await session.sendCommand('Debugger.setSkipAllPauses', {skip: true});
+    await session.sendCommand('Debugger.setAsyncCallStackDepth', {maxDepth: 8});
+  };
+
+  /**
+   * Resume any pauses that make it through `setSkipAllPauses`
+   */
+  function onDebuggerPaused() {
+    session.sendCommand('Debugger.resume');
+  }
+
+  /**
+   * `Debugger.setSkipAllPauses` is reset after every navigation, so retrigger it on main frame navigations.
+   * See https://bugs.chromium.org/p/chromium/issues/detail?id=990945&q=setSkipAllPauses&can=2
+   * @param {LH.Crdp.Page.FrameNavigatedEvent} event
+   */
+  function onFrameNavigated(event) {
+    if (event.frame.parentId) return;
+    enable().catch(err => log.error('Driver', err));
+  }
+
+  session.on('Debugger.paused', onDebuggerPaused);
+  session.on('Page.frameNavigated', onFrameNavigated);
+
+  await enable();
+
+  return async () => {
+    await session.sendCommand('Debugger.disable');
+    session.off('Debugger.paused', onDebuggerPaused);
+    session.off('Page.frameNavigated', onFrameNavigated);
+  };
+}
+
+/**
+ * Use a RequestIdleCallback shim for tests run with simulated throttling, so that the deadline can be used without
+ * a penalty.
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ * @param {LH.Config.Settings} settings
+ * @return {Promise<void>}
+ */
+async function shimRequestIdleCallbackOnNewDocument(driver, settings) {
+  await driver.executionContext.evaluateOnNewDocument(pageFunctions.wrapRequestIdleCallback, {
+    args: [settings.throttling.cpuSlowdownMultiplier],
+  });
+}
+
+/**
+ * Dismiss JavaScript dialogs (alert, confirm, prompt), providing a
+ * generic promptText in case the dialog is a prompt.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @return {Promise<void>}
+ */
+async function dismissJavaScriptDialogs(session) {
+  session.on('Page.javascriptDialogOpening', data => {
+    log.warn('Driver', `${data.type} dialog opened by the page automatically suppressed.`);
+
+    session
+      .sendCommand('Page.handleJavaScriptDialog', {
+        accept: true,
+        promptText: 'Lighthouse prompt response',
+      })
+      .catch(err => log.warn('Driver', err));
+  });
+
+  await session.sendCommand('Page.enable');
+}
+
+/**
+ * Reset the storage and warn if any stored data could be affecting the scores.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {string} url
+ * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
+ */
+async function resetStorageForUrl(session, url) {
+  /** @type {Array<LH.IcuMessage>} */
+  const warnings = [];
+
+  const importantStorageWarning = await storage.getImportantStorageWarning(session, url);
+  if (importantStorageWarning) warnings.push(importantStorageWarning);
+
+  const clearDataWarnings = await storage.clearDataForOrigin(session, url);
+  warnings.push(...clearDataWarnings);
+
+  const clearCacheWarnings = await storage.clearBrowserCaches(session);
+  warnings.push(...clearCacheWarnings);
+
+  return {warnings};
+}
+
+/**
+ * Prepares a target for observational analysis by setting throttling and network headers/blocked patterns.
+ *
+ * This method assumes `prepareTargetForNavigationMode` or `prepareTargetForTimespanMode` has already been invoked.
+ *
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Config.Settings} settings
+ * @param {{disableThrottling: boolean, blockedUrlPatterns?: string[]}} options
+ */
+async function prepareThrottlingAndNetwork(session, settings, options) {
+  const status = {msg: 'Preparing network conditions', id: `lh:gather:prepareThrottlingAndNetwork`};
+  log.time(status);
+
+  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 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});
+
+  const headers = settings.extraHeaders;
+  if (headers) await session.sendCommand('Network.setExtraHTTPHeaders', {headers});
+
+  log.timeEnd(status);
+}
+
+/**
+ * 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 prepareDeviceEmulation(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.
+  await emulation.emulate(driver.defaultSession, settings);
+}
+
+/**
+ * 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) {
+  const status = {msg: 'Preparing target for timespan mode', id: 'lh:prepare:timespanMode'};
+  log.time(status);
+
+  await prepareDeviceEmulation(driver, settings);
+  await prepareThrottlingAndNetwork(driver.defaultSession, settings, {
+    disableThrottling: false,
+    blockedUrlPatterns: undefined,
+  });
+
+  log.timeEnd(status);
+}
+
+/**
+ * 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) {
+  const status = {msg: 'Preparing target for navigation mode', id: 'lh:prepare:navigationMode'};
+  log.time(status);
+
+  await prepareDeviceEmulation(driver, settings);
+
+  // Automatically handle any JavaScript dialogs to prevent a hung renderer.
+  await dismissJavaScriptDialogs(driver.defaultSession);
+
+  // Inject our snippet to cache important web platform APIs before they're (possibly) ponyfilled by the page.
+  await driver.executionContext.cacheNativesOnNewDocument();
+
+  // Wrap requestIdleCallback so pages under simulation receive the correct rIC deadlines.
+  if (settings.throttlingMethod === 'simulate') {
+    await shimRequestIdleCallbackOnNewDocument(driver, settings);
+  }
+
+  log.timeEnd(status);
+}
+
+/**
+ * Prepares a target for a particular navigation by resetting storage and setting network.
+ *
+ * This method assumes `prepareTargetForNavigationMode` has already been invoked.
+ *
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @param {LH.Config.Settings} settings
+ * @param {Pick<LH.Config.NavigationDefn, 'disableThrottling'|'disableStorageReset'|'blockedUrlPatterns'> & {requestor: LH.NavigationRequestor}} navigation
+ * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
+ */
+async function prepareTargetForIndividualNavigation(session, settings, navigation) {
+  const status = {msg: 'Preparing target for navigation', id: 'lh:prepare:navigation'};
+  log.time(status);
+
+  /** @type {Array<LH.IcuMessage>} */
+  const warnings = [];
+
+  const {requestor} = navigation;
+  const shouldResetStorage =
+    !settings.disableStorageReset &&
+    !navigation.disableStorageReset &&
+    // Without prior knowledge of the destination, we cannot know which URL to clear storage for.
+    typeof requestor === 'string';
+  if (shouldResetStorage) {
+    const requestedUrl = requestor;
+    const {warnings: storageWarnings} = await resetStorageForUrl(session, requestedUrl);
+    warnings.push(...storageWarnings);
+  }
+
+  await prepareThrottlingAndNetwork(session, settings, navigation);
+
+  log.timeEnd(status);
+  return {warnings};
+}
+
+export {
+  prepareThrottlingAndNetwork,
+  prepareTargetForTimespanMode,
+  prepareTargetForNavigationMode,
+  prepareTargetForIndividualNavigation,
+  enableAsyncStacks,
+};

package/core/gather/driver/service-workers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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.
+ */
+/**
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @return {Promise<LH.Crdp.ServiceWorker.WorkerVersionUpdatedEvent>}
+ */
+export function getServiceWorkerVersions(session: LH.Gatherer.FRProtocolSession): Promise<LH.Crdp.ServiceWorker.WorkerVersionUpdatedEvent>;
+/**
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @return {Promise<LH.Crdp.ServiceWorker.WorkerRegistrationUpdatedEvent>}
+ */
+export function getServiceWorkerRegistrations(session: LH.Gatherer.FRProtocolSession): Promise<LH.Crdp.ServiceWorker.WorkerRegistrationUpdatedEvent>;
+//# sourceMappingURL=service-workers.d.ts.map

package/core/gather/driver/service-workers.js

@@ -0,0 +1,52 @@
+/**
+ * @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.
+ */
+
+/**
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @return {Promise<LH.Crdp.ServiceWorker.WorkerVersionUpdatedEvent>}
+ */
+function getServiceWorkerVersions(session) {
+  return new Promise((resolve, reject) => {
+    /**
+     * @param {LH.Crdp.ServiceWorker.WorkerVersionUpdatedEvent} data
+     */
+    const versionUpdatedListener = data => {
+      // find a service worker with runningStatus that looks like active
+      // on slow connections the serviceworker might still be installing
+      const activateCandidates = data.versions.filter(sw => {
+        return sw.status !== 'redundant';
+      });
+
+      const hasActiveServiceWorker = activateCandidates.find(sw => {
+        return sw.status === 'activated';
+      });
+
+      if (!activateCandidates.length || hasActiveServiceWorker) {
+        session.off('ServiceWorker.workerVersionUpdated', versionUpdatedListener);
+        session.sendCommand('ServiceWorker.disable').then(_ => resolve(data), reject);
+      }
+    };
+
+    session.on('ServiceWorker.workerVersionUpdated', versionUpdatedListener);
+
+    session.sendCommand('ServiceWorker.enable').catch(reject);
+  });
+}
+
+/**
+ * @param {LH.Gatherer.FRProtocolSession} session
+ * @return {Promise<LH.Crdp.ServiceWorker.WorkerRegistrationUpdatedEvent>}
+ */
+function getServiceWorkerRegistrations(session) {
+  return new Promise((resolve, reject) => {
+    session.once('ServiceWorker.workerRegistrationUpdated', data => {
+      session.sendCommand('ServiceWorker.disable').then(_ => resolve(data), reject);
+    });
+    session.sendCommand('ServiceWorker.enable').catch(reject);
+  });
+}
+
+export {getServiceWorkerVersions, getServiceWorkerRegistrations};