lighthouse 9.6.8 → 10.0.0

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

@@ -1,36 +0,0 @@
-/**
- * @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 gatherer remaps the result of the Trace gatherer for compatibility with legacy Lighthouse
- * when devtools logs and traces were special-cased.
- */
-
-const TraceGatherer = require('./trace.js');
-const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
-
-/** @implements {LH.Gatherer.FRGathererInstance<'Trace'>} */
-class TraceCompat extends FRGatherer {
-  /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
-  meta = {
-    supportedModes: ['timespan', 'navigation'],
-    dependencies: {Trace: TraceGatherer.symbol},
-  };
-
-  /**
-   * @param {LH.Gatherer.FRTransitionalContext<'Trace'>} passContext
-   * @return {Promise<LH.Artifacts['traces']>}
-   */
-  async getArtifact(passContext) {
-    return {
-      defaultPass: passContext.dependencies.Trace,
-    };
-  }
-}
-
-module.exports = TraceCompat;

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

@@ -1,349 +0,0 @@
-/**
- * @license Copyright 2020 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';
-
-/* global getNodeDetails */
-
-/**
- * @fileoverview
- * This gatherer identifies elements that contribrute to metrics in the trace (LCP, CLS, etc.).
- * We take the backend nodeId from the trace and use it to find the corresponding element in the DOM.
- */
-
-const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
-const {resolveNodeIdToObjectId} = require('../driver/dom.js');
-const pageFunctions = require('../../lib/page-functions.js');
-const RectHelpers = require('../../lib/rect-helpers.js');
-const Sentry = require('../../lib/sentry.js');
-const Trace = require('./trace.js');
-const ProcessedTrace = require('../../computed/processed-trace.js');
-const ProcessedNavigation = require('../../computed/processed-navigation.js');
-const LighthouseError = require('../../lib/lh-error.js');
-const ComputedResponsivenes = require('../../computed/metrics/responsiveness.js');
-
-/** @typedef {{nodeId: number, score?: number, animations?: {name?: string, failureReasonsMask?: number, unsupportedProperties?: string[]}[], type?: string}} TraceElementData */
-
-/**
- * @this {HTMLElement}
- */
-/* c8 ignore start */
-function getNodeDetailsData() {
-  const elem = this.nodeType === document.ELEMENT_NODE ? this : this.parentElement; // eslint-disable-line no-undef
-  let traceElement;
-  if (elem) {
-    // @ts-expect-error - getNodeDetails put into scope via stringification
-    traceElement = {node: getNodeDetails(elem)};
-  }
-  return traceElement;
-}
-/* c8 ignore stop */
-
-class TraceElements extends FRGatherer {
-  /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
-  meta = {
-    supportedModes: ['timespan', 'navigation'],
-    dependencies: {Trace: Trace.symbol},
-  };
-
-  /** @type {Map<string, string>} */
-  animationIdToName = new Map();
-
-  constructor() {
-    super();
-    this._onAnimationStarted = this._onAnimationStarted.bind(this);
-  }
-
-  /** @param {LH.Crdp.Animation.AnimationStartedEvent} args */
-  _onAnimationStarted({animation: {id, name}}) {
-    if (name) this.animationIdToName.set(id, name);
-  }
-
-  /**
-   * @param {Array<number>} rect
-   * @return {LH.Artifacts.Rect}
-   */
-  static traceRectToLHRect(rect) {
-    const rectArgs = {
-      x: rect[0],
-      y: rect[1],
-      width: rect[2],
-      height: rect[3],
-    };
-    return RectHelpers.addRectTopAndBottom(rectArgs);
-  }
-
-  /**
-   * This function finds the top (up to 5) elements that contribute to the CLS score of the page.
-   * Each layout shift event has a 'score' which is the amount added to the CLS as a result of the given shift(s).
-   * We calculate the score per element by taking the 'score' of each layout shift event and
-   * distributing it between all the nodes that were shifted, proportianal to the impact region of
-   * each shifted element.
-   * @param {Array<LH.TraceEvent>} mainThreadEvents
-   * @return {Array<TraceElementData>}
-   */
-  static getTopLayoutShiftElements(mainThreadEvents) {
-    /** @type {Map<number, number>} */
-    const clsPerNode = new Map();
-    const shiftEvents = mainThreadEvents
-      .filter(e => e.name === 'LayoutShift')
-      .map(e => e.args?.data);
-    const indexFirstEventWithoutInput =
-      shiftEvents.findIndex(event => event && !event.had_recent_input);
-
-    shiftEvents.forEach((event, index) => {
-      if (!event || !event.impacted_nodes || !event.score) {
-        return;
-      }
-
-      // Ignore events with input, unless it's one of the initial events.
-      // See comment in computed/metrics/cumulative-layout-shift.js.
-      if (indexFirstEventWithoutInput !== -1 && index >= indexFirstEventWithoutInput) {
-        if (event.had_recent_input) return;
-      }
-
-      let totalAreaOfImpact = 0;
-      /** @type {Map<number, number>} */
-      const pixelsMovedPerNode = new Map();
-
-      event.impacted_nodes.forEach(node => {
-        if (!node.node_id || !node.old_rect || !node.new_rect) {
-          return;
-        }
-
-        const oldRect = TraceElements.traceRectToLHRect(node.old_rect);
-        const newRect = TraceElements.traceRectToLHRect(node.new_rect);
-        const areaOfImpact = RectHelpers.getRectArea(oldRect) +
-          RectHelpers.getRectArea(newRect) -
-          RectHelpers.getRectOverlapArea(oldRect, newRect);
-
-        pixelsMovedPerNode.set(node.node_id, areaOfImpact);
-        totalAreaOfImpact += areaOfImpact;
-      });
-
-      for (const [nodeId, pixelsMoved] of pixelsMovedPerNode.entries()) {
-        let clsContribution = clsPerNode.get(nodeId) || 0;
-        clsContribution += (pixelsMoved / totalAreaOfImpact) * event.score;
-        clsPerNode.set(nodeId, clsContribution);
-      }
-    });
-
-    const topFive = [...clsPerNode.entries()]
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, 5)
-    .map(([nodeId, clsContribution]) => {
-      return {
-        nodeId: nodeId,
-        score: clsContribution,
-      };
-    });
-
-    return topFive;
-  }
-
-  /**
-   * @param {LH.Trace} trace
-   * @param {LH.Gatherer.FRTransitionalContext} context
-   * @return {Promise<TraceElementData|undefined>}
-   */
-  static async getResponsivenessElement(trace, context) {
-    const {settings} = context;
-    try {
-      const responsivenessEvent = await ComputedResponsivenes.request({trace, settings}, context);
-      if (!responsivenessEvent || responsivenessEvent.name === 'FallbackTiming') return;
-      return {nodeId: responsivenessEvent.args.data.nodeId};
-    } catch {
-      // Don't let responsiveness errors sink the rest of the gatherer.
-      return;
-    }
-  }
-
-  /**
-   * Find the node ids of elements which are animated using the Animation trace events.
-   * @param {Array<LH.TraceEvent>} mainThreadEvents
-   * @return {Promise<Array<TraceElementData>>}
-   */
-  async getAnimatedElements(mainThreadEvents) {
-    /** @type {Map<string, {begin: LH.TraceEvent | undefined, status: LH.TraceEvent | undefined}>} */
-    const animationPairs = new Map();
-    for (const event of mainThreadEvents) {
-      if (event.name !== 'Animation') continue;
-
-      if (!event.id2 || !event.id2.local) continue;
-      const local = event.id2.local;
-
-      const pair = animationPairs.get(local) || {begin: undefined, status: undefined};
-      if (event.ph === 'b') {
-        pair.begin = event;
-      } else if (
-        event.ph === 'n' &&
-          event.args.data &&
-          event.args.data.compositeFailed !== undefined) {
-        pair.status = event;
-      }
-      animationPairs.set(local, pair);
-    }
-
-    /** @type {Map<number, Set<{animationId: string, failureReasonsMask?: number, unsupportedProperties?: string[]}>>} */
-    const elementAnimations = new Map();
-    for (const {begin, status} of animationPairs.values()) {
-      const nodeId = begin?.args?.data?.nodeId;
-      const animationId = begin?.args?.data?.id;
-      const failureReasonsMask = status?.args?.data?.compositeFailed;
-      const unsupportedProperties = status?.args?.data?.unsupportedProperties;
-      if (!nodeId || !animationId) continue;
-
-      const animationIds = elementAnimations.get(nodeId) || new Set();
-      animationIds.add({animationId, failureReasonsMask, unsupportedProperties});
-      elementAnimations.set(nodeId, animationIds);
-    }
-
-    /** @type {Array<TraceElementData>} */
-    const animatedElementData = [];
-    for (const [nodeId, animationIds] of elementAnimations) {
-      const animations = [];
-      for (const {animationId, failureReasonsMask, unsupportedProperties} of animationIds) {
-        const animationName = this.animationIdToName.get(animationId);
-        animations.push({name: animationName, failureReasonsMask, unsupportedProperties});
-      }
-      animatedElementData.push({nodeId, animations});
-    }
-    return animatedElementData;
-  }
-
-  /**
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
-   * @param {LH.Gatherer.FRTransitionalContext} context
-   * @return {Promise<{nodeId: number, type: string} | undefined>}
-   */
-  static async getLcpElement(processedTrace, context) {
-    let processedNavigation;
-    try {
-      processedNavigation = await ProcessedNavigation.request(processedTrace, context);
-    } catch (err) {
-      // If we were running in timespan mode and there was no paint, treat LCP as missing.
-      if (context.gatherMode === 'timespan' && err.code === LighthouseError.errors.NO_FCP.code) {
-        return;
-      }
-
-      throw err;
-    }
-
-    // These should exist, but trace types are loose.
-    const lcpData = processedNavigation.largestContentfulPaintEvt?.args?.data;
-    if (lcpData?.nodeId === undefined || !lcpData.type) return;
-
-    return {
-      nodeId: lcpData.nodeId,
-      type: lcpData.type,
-    };
-  }
-
-  /**
-   * @param {LH.Gatherer.FRTransitionalContext} context
-   */
-  async startInstrumentation(context) {
-    await context.driver.defaultSession.sendCommand('Animation.enable');
-    context.driver.defaultSession.on('Animation.animationStarted', this._onAnimationStarted);
-  }
-
-  /**
-   * @param {LH.Gatherer.FRTransitionalContext} context
-   */
-  async stopInstrumentation(context) {
-    context.driver.defaultSession.off('Animation.animationStarted', this._onAnimationStarted);
-    await context.driver.defaultSession.sendCommand('Animation.disable');
-  }
-
-  /**
-   * @param {LH.Gatherer.FRTransitionalContext} context
-   * @param {LH.Trace|undefined} trace
-   * @return {Promise<LH.Artifacts['TraceElements']>}
-   */
-  async _getArtifact(context, trace) {
-    const session = context.driver.defaultSession;
-    if (!trace) {
-      throw new Error('Trace is missing!');
-    }
-
-    const processedTrace = await ProcessedTrace.request(trace, context);
-    const {mainThreadEvents} = processedTrace;
-
-    const lcpNodeData = await TraceElements.getLcpElement(processedTrace, context);
-    const clsNodeData = TraceElements.getTopLayoutShiftElements(mainThreadEvents);
-    const animatedElementData = await this.getAnimatedElements(mainThreadEvents);
-    const responsivenessElementData = await TraceElements.getResponsivenessElement(trace, context);
-
-    /** @type {Map<string, TraceElementData[]>} */
-    const backendNodeDataMap = new Map([
-      ['largest-contentful-paint', lcpNodeData ? [lcpNodeData] : []],
-      ['layout-shift', clsNodeData],
-      ['animation', animatedElementData],
-      ['responsiveness', responsivenessElementData ? [responsivenessElementData] : []],
-    ]);
-
-    const traceElements = [];
-    for (const [traceEventType, backendNodeData] of backendNodeDataMap) {
-      for (let i = 0; i < backendNodeData.length; i++) {
-        const backendNodeId = backendNodeData[i].nodeId;
-        let response;
-        try {
-          const objectId = await resolveNodeIdToObjectId(session, backendNodeId);
-          if (!objectId) continue;
-          response = await session.sendCommand('Runtime.callFunctionOn', {
-            objectId,
-            functionDeclaration: `function () {
-              ${getNodeDetailsData.toString()};
-              ${pageFunctions.getNodeDetailsString};
-              return getNodeDetailsData.call(this);
-            }`,
-            returnByValue: true,
-            awaitPromise: true,
-          });
-        } catch (err) {
-          Sentry.captureException(err, {
-            tags: {gatherer: this.name},
-            level: 'error',
-          });
-          continue;
-        }
-
-        if (response?.result?.value) {
-          traceElements.push({
-            traceEventType,
-            ...response.result.value,
-            score: backendNodeData[i].score,
-            animations: backendNodeData[i].animations,
-            nodeId: backendNodeId,
-            type: backendNodeData[i].type,
-          });
-        }
-      }
-    }
-
-    return traceElements;
-  }
-
-  /**
-   * @param {LH.Gatherer.FRTransitionalContext<'Trace'>} context
-   * @return {Promise<LH.Artifacts.TraceElement[]>}
-   */
-  async getArtifact(context) {
-    return this._getArtifact(context, context.dependencies.Trace);
-  }
-
-  /**
-   * @param {LH.Gatherer.PassContext} passContext
-   * @param {LH.Gatherer.LoadData} loadData
-   * @return {Promise<LH.Artifacts.TraceElement[]>}
-   */
-  async afterPass(passContext, loadData) {
-    const context = {...passContext, dependencies: {}};
-    await this.stopInstrumentation(context);
-    return this._getArtifact(context, loadData.trace);
-  }
-}
-
-module.exports = TraceElements;

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

@@ -1,131 +0,0 @@
-/**
- * @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 gatherer collects all network and page devtools protocol traffic during the timespan/navigation.
- * This protocol log can be used to recreate the network records using lib/network-recorder.js.
- */
-
-const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
-const TraceProcessor = require('../../lib/tracehouse/trace-processor.js');
-
-class Trace extends FRGatherer {
-  /** @type {LH.Trace} */
-  _trace = {traceEvents: []};
-
-  static getDefaultTraceCategories() {
-    return [
-      // Exclude default categories. We'll be selective to minimize trace size
-      '-*',
-
-      // Used instead of 'toplevel' in Chrome 71+
-      'disabled-by-default-lighthouse',
-
-      // Used for Cumulative Layout Shift metric
-      'loading',
-
-      // All compile/execute events are captured by parent events in devtools.timeline..
-      // But the v8 category provides some nice context for only <0.5% of the trace size
-      'v8',
-      // Same situation here. This category is there for RunMicrotasks only, but with other teams
-      // accidentally excluding microtasks, we don't want to assume a parent event will always exist
-      'v8.execute',
-
-      // For extracting UserTiming marks/measures
-      'blink.user_timing',
-
-      // Not mandatory but not used much
-      'blink.console',
-
-      // Most of the events we need are from these two categories
-      'devtools.timeline',
-      'disabled-by-default-devtools.timeline',
-
-      // Up to 450 (https://goo.gl/rBfhn4) JPGs added to the trace
-      'disabled-by-default-devtools.screenshot',
-
-      // This doesn't add its own events, but adds a `stackTrace` property to devtools.timeline events
-      'disabled-by-default-devtools.timeline.stack',
-
-      // Additional categories used by devtools. Not used by Lighthouse, but included to facilitate
-      // loading traces from Lighthouse into the Performance panel.
-      'disabled-by-default-devtools.timeline.frame',
-      'latencyInfo',
-
-      // 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',
-    ];
-  }
-
-  /**
-   * @param {LH.Gatherer.FRProtocolSession} session
-   * @return {Promise<LH.Trace>}
-   */
-  static async endTraceAndCollectEvents(session) {
-    /** @type {Array<LH.TraceEvent>} */
-    const traceEvents = [];
-
-    /**
-     * Listener for when dataCollected events fire for each trace chunk
-     * @param {LH.Crdp.Tracing.DataCollectedEvent} data
-     */
-    const dataListener = function(data) {
-      traceEvents.push(...data.value);
-    };
-    session.on('Tracing.dataCollected', dataListener);
-
-    return new Promise((resolve, reject) => {
-      session.once('Tracing.tracingComplete', _ => {
-        session.off('Tracing.dataCollected', dataListener);
-        resolve({traceEvents});
-      });
-
-      session.sendCommand('Tracing.end').catch(reject);
-    });
-  }
-
-  static symbol = Symbol('Trace');
-
-  /** @type {LH.Gatherer.GathererMeta} */
-  meta = {
-    symbol: Trace.symbol,
-    supportedModes: ['timespan', 'navigation'],
-  };
-
-  /**
-   * @param {LH.Gatherer.FRTransitionalContext} passContext
-   */
-  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: traceCategories.join(','),
-      options: 'sampling-frequency=10000', // 1000 is default and too slow.
-    });
-
-    if (gatherMode === 'timespan') {
-      await driver.defaultSession.sendCommand('Tracing.recordClockSyncMarker',
-        {syncId: TraceProcessor.TIMESPAN_MARKER_ID});
-    }
-  }
-
-  /**
-   * @param {LH.Gatherer.FRTransitionalContext} passContext
-   */
-  async stopSensitiveInstrumentation({driver}) {
-    this._trace = await Trace.endTraceAndCollectEvents(driver.defaultSession);
-  }
-
-  getArtifact() {
-    return this._trace;
-  }
-}
-
-module.exports = Trace;

package/lighthouse-core/gather/gatherers/viewport-dimensions.js

@@ -1,58 +0,0 @@
-/**
- * @license Copyright 2016 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';
-
-const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
-
-/* global window */
-
-/**
- * @return {LH.Artifacts.ViewportDimensions}
- */
-/* c8 ignore start */
-function getViewportDimensions() {
-  // window.innerWidth to get the scrollable size of the window (irrespective of zoom)
-  // window.outerWidth to get the size of the visible area
-  // window.devicePixelRatio to get ratio of logical pixels to physical pixels
-  return {
-    innerWidth: window.innerWidth,
-    innerHeight: window.innerHeight,
-    outerWidth: window.outerWidth,
-    outerHeight: window.outerHeight,
-    devicePixelRatio: window.devicePixelRatio,
-  };
-}
-/* c8 ignore stop */
-
-class ViewportDimensions extends FRGatherer {
-  /** @type {LH.Gatherer.GathererMeta} */
-  meta = {
-    supportedModes: ['snapshot', 'timespan', 'navigation'],
-  };
-
-  /**
-   * @param {LH.Gatherer.FRTransitionalContext} passContext
-   * @return {Promise<LH.Artifacts.ViewportDimensions>}
-   */
-  async getArtifact(passContext) {
-    const driver = passContext.driver;
-
-    const dimensions = await driver.executionContext.evaluate(getViewportDimensions, {
-      args: [],
-      useIsolation: true,
-    });
-
-    const allNumeric = Object.values(dimensions).every(Number.isFinite);
-    if (!allNumeric) {
-      const results = JSON.stringify(dimensions);
-      throw new Error(`ViewportDimensions results were not numeric: ${results}`);
-    }
-
-    return dimensions;
-  }
-}
-
-module.exports = ViewportDimensions;

package/lighthouse-core/gather/gatherers/web-app-manifest.js

@@ -1,102 +0,0 @@
-/**
- * @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';
-
-const log = require('lighthouse-logger');
-const manifestParser = require('../../lib/manifest-parser.js');
-const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
-
-class WebAppManifest extends FRGatherer {
-  /** @type {LH.Gatherer.GathererMeta} */
-  meta = {
-    supportedModes: ['snapshot', 'navigation'],
-  };
-
-  /**
-   * @param {LH.Gatherer.FRProtocolSession} session
-   * @return {Promise<{url: string, data: string}|null>}
-   */
-  static async fetchAppManifest(session) {
-    // In all environments but LR, Page.getAppManifest finishes very quickly.
-    // In LR, there is a bug that causes this command to hang until outgoing
-    // requests finish. This has been seen in long polling (where it will never
-    // return) and when other requests take a long time to finish. We allow 10 seconds
-    // for outgoing requests to finish. Anything more, and we continue the run without
-    // a manifest.
-    // Googlers, see: http://b/124008171
-    session.setNextProtocolTimeout(10000);
-    let response;
-    try {
-      response = await session.sendCommand('Page.getAppManifest');
-    } catch (err) {
-      if (err.code === 'PROTOCOL_TIMEOUT') {
-        // LR will timeout fetching the app manifest in some cases, move on without one.
-        // https://github.com/GoogleChrome/lighthouse/issues/7147#issuecomment-461210921
-        log.error('WebAppManifest', 'Failed fetching manifest', err);
-        return null;
-      }
-
-      throw err;
-    }
-
-    let data = response.data;
-
-    // We're not reading `response.errors` however it may contain critical and noncritical
-    // errors from Blink's manifest parser:
-    //   https://chromedevtools.github.io/debugger-protocol-viewer/tot/Page/#type-AppManifestError
-    if (!data) {
-      // If the data is empty, the page had no manifest.
-      return null;
-    }
-
-    const BOM_LENGTH = 3;
-    const BOM_FIRSTCHAR = 65279;
-    const isBomEncoded = data.charCodeAt(0) === BOM_FIRSTCHAR;
-
-    if (isBomEncoded) {
-      data = Buffer.from(data)
-        .slice(BOM_LENGTH)
-        .toString();
-    }
-
-    return {...response, data};
-  }
-
-  /**
-   * Uses the debugger protocol to fetch the manifest from within the context of
-   * the target page, reusing any credentials, emulation, etc, already established
-   * there.
-   *
-   * Returns the parsed manifest or null if the page had no manifest. If the manifest
-   * was unparseable as JSON, manifest.value will be undefined and manifest.warning
-   * will have the reason. See manifest-parser.js for more information.
-   *
-   * @param {LH.Gatherer.FRProtocolSession} session
-   * @param {string} pageUrl
-   * @return {Promise<LH.Artifacts.Manifest|null>}
-   */
-  static async getWebAppManifest(session, pageUrl) {
-    const status = {msg: 'Get webapp manifest', id: 'lh:gather:getWebAppManifest'};
-    log.time(status);
-    const response = await WebAppManifest.fetchAppManifest(session);
-    if (!response) return null;
-    const manifest = manifestParser(response.data, response.url, pageUrl);
-    log.timeEnd(status);
-    return manifest;
-  }
-
-  /**
-   * @param {LH.Gatherer.FRTransitionalContext} context
-   * @return {Promise<LH.Artifacts['WebAppManifest']>}
-   */
-  getArtifact(context) {
-    const driver = context.driver;
-
-    return WebAppManifest.getWebAppManifest(driver.defaultSession, context.url);
-  }
-}
-
-module.exports = WebAppManifest;