lighthouse 9.5.0-dev.20220509 → 9.5.0-dev.20220512

package/lighthouse-core/audits/metrics/experimental-interaction-to-next-paint.js

@@ -70,7 +70,9 @@ class ExperimentalInteractionToNextPaint extends Audit {
       return {score: null, notApplicable: true};
     }
 
-    const timing = interactionEvent.args.data.duration;
+    // TODO: remove workaround once 103.0.5052.0 is sufficiently released.
+    const timing = interactionEvent.name === 'FallbackTiming' ?
+        interactionEvent.duration : interactionEvent.args.data.duration;
 
     return {
       score: Audit.computeLogNormalScore({p10: context.options.p10, median: context.options.median},

package/lighthouse-core/audits/work-during-interaction.js

@@ -0,0 +1,280 @@
+/**
+ * @license Copyright 2022 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 Audit = require('./audit.js');
+const ComputedResponsivenes = require('../computed/metrics/responsiveness.js');
+const ProcessedTrace = require('../computed/processed-trace.js');
+const i18n = require('../lib/i18n/i18n.js');
+const NetworkRecords = require('../computed/network-records.js');
+const MainThreadTasks = require('../lib/tracehouse/main-thread-tasks.js');
+const {taskGroups} = require('../lib/tracehouse/task-groups.js');
+const TraceProcessor = require('../lib/tracehouse/trace-processor.js');
+const {getExecutionTimingsByURL} = require('../lib/tracehouse/task-summary.js');
+const inpThresholds = require('./metrics/experimental-interaction-to-next-paint.js').defaultOptions;
+const LHError = require('../lib/lh-error.js');
+
+/** @typedef {import('../computed/metrics/responsiveness.js').EventTimingEvent} EventTimingEvent */
+/** @typedef {import('../lib/tracehouse/main-thread-tasks.js').TaskNode} TaskNode */
+
+const TASK_THRESHOLD = 1;
+
+const UIStrings = {
+  /** Title of a diagnostic audit that provides detail on the main thread work the browser did during a key user interaction. This descriptive title is shown to users when the amount is acceptable and no user action is required. */
+  title: 'Minimizes work during key interaction',
+  /** Title of a diagnostic audit that provides detail on the main thread work the browser did during a key user interaction. This imperative title is shown to users when there is a significant amount of execution time that could be reduced. */
+  failureTitle: 'Minimize work during key interaction',
+  /** Description of the work-during-interaction metric. This description is displayed within a tooltip when the user hovers on the metric name to see more. No character length limits. 'Learn More' becomes link text to additional documentation. */
+  description: 'This is the thread-blocking work occurring during the Interaction to Next Paint measurement. [Learn more](https://web.dev/inp/).',
+  /** Label for a column in a data table; entries will be information on the time that the browser is delayed before responding to user input. Ideally fits within a ~40 character limit. */
+  inputDelay: 'Input delay',
+  /** Label for a column in a data table; entries will be information on the time taken by code processing user input that delays a response to the user. Ideally fits within a ~40 character limit. */
+  processingDelay: 'Processing delay',
+  /** Label for a column in a data table; entries will be information on the time that the browser is delayed before presenting a response to user input on screen. Ideally fits within a ~40 character limit. */
+  presentationDelay: 'Presentation delay',
+  /**
+   * @description Summary text that identifies the time the browser took to process a user interaction.
+   * @example {mousedown} interactionType
+   */
+  displayValue: `{timeInMs, number, milliseconds}\xa0ms spent on event '{interactionType}'`,
+  /** Label for a column in a data table; entries will the UI element that was the target of a user interaction (for example, a button that was clicked on). Ideally fits within a ~40 character limit. */
+  eventTarget: 'Event target',
+};
+
+const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings);
+
+/**
+ * @fileoverview This metric gives a high-percentile measure of responsiveness to input.
+ */
+class WorkDuringInteraction extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'work-during-interaction',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      supportedModes: ['timespan'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'TraceElements'],
+    };
+  }
+
+  /**
+   * @param {TaskNode} task
+   * @param {TaskNode|undefined} parent
+   * @param {number} startTs
+   * @param {number} endTs
+   * @return {number}
+   */
+  static recursivelyClipTasks(task, parent, startTs, endTs) {
+    const taskEventStart = task.event.ts;
+    const taskEventEnd = task.endEvent?.ts ?? task.event.ts + Number(task.event.dur || 0);
+
+    task.startTime = Math.max(startTs, Math.min(endTs, taskEventStart)) / 1000;
+    task.endTime = Math.max(startTs, Math.min(endTs, taskEventEnd)) / 1000;
+    task.duration = task.endTime - task.startTime;
+
+    const childTime = task.children
+      .map(child => WorkDuringInteraction.recursivelyClipTasks(child, task, startTs, endTs))
+      .reduce((sum, child) => sum + child, 0);
+    task.selfTime = task.duration - childTime;
+    return task.duration;
+  }
+
+  /**
+   * Clip the tasks by the start and end points. Take the easy route and drop
+   * to duration 0 if out of bounds, since only durations are needed in the
+   * end (for now).
+   * Assumes owned tasks, so modifies in place. Can be called multiple times on
+   * the same `tasks` because always computed from original event timing.
+   * @param {Array<TaskNode>} tasks
+   * @param {number} startTs
+   * @param {number} endTs
+   */
+  static clipTasksByTs(tasks, startTs, endTs) {
+    for (const task of tasks) {
+      if (task.parent) continue;
+      WorkDuringInteraction.recursivelyClipTasks(task, undefined, startTs, endTs);
+    }
+  }
+
+  /**
+   * @param {EventTimingEvent} interactionEvent
+   */
+  static getPhaseTimes(interactionEvent) {
+    const interactionData = interactionEvent.args.data;
+    const startTs = interactionEvent.ts;
+    const navStart = startTs - interactionData.timeStamp * 1000;
+    const processingStartTs = navStart + interactionData.processingStart * 1000;
+    const processingEndTs = navStart + interactionData.processingEnd * 1000;
+    const endTs = startTs + interactionData.duration * 1000;
+    return {
+      inputDelay: {startTs, endTs: processingStartTs},
+      processingDelay: {startTs: processingStartTs, endTs: processingEndTs},
+      presentationDelay: {startTs: processingEndTs, endTs},
+    };
+  }
+
+  /**
+   * @param {EventTimingEvent} interactionEvent
+   * @param {LH.Trace} trace
+   * @param {LH.Artifacts.ProcessedTrace} processedTrace
+   * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+   * @return {{table: LH.Audit.Details.Table, phases: Record<string, {startTs: number, endTs: number}>}}
+   */
+  static getThreadBreakdownTable(interactionEvent, trace, processedTrace, networkRecords) {
+    // Limit to interactionEvent's thread.
+    // TODO(bckenny): limit to interactionEvent's navigation.
+    const threadEvents = TraceProcessor.filteredTraceSort(trace.traceEvents, evt => {
+      return evt.pid === interactionEvent.pid && evt.tid === interactionEvent.tid;
+    });
+    const traceEndTs = threadEvents.reduce((endTs, evt) => {
+      return Math.max(evt.ts + (evt.dur || 0), endTs);
+    }, 0);
+    // frames is only used for URL attribution, so can include all frames, even if OOPIF.
+    const {frames} = processedTrace;
+    const threadTasks = MainThreadTasks.getMainThreadTasks(threadEvents, frames, traceEndTs);
+
+    const phases = WorkDuringInteraction.getPhaseTimes(interactionEvent);
+
+    /** @type {LH.Audit.Details.TableItem[]} */
+    const items = [];
+    for (const [phaseName, phaseTimes] of Object.entries(phases)) {
+      // Clip tasks to start and end time.
+      WorkDuringInteraction.clipTasksByTs(threadTasks, phaseTimes.startTs, phaseTimes.endTs);
+      const executionTimings = getExecutionTimingsByURL(threadTasks, networkRecords);
+
+      const results = [];
+      for (const [url, timingByGroupId] of executionTimings) {
+        const totalExecutionTimeForURL = Object.values(timingByGroupId)
+            .reduce((total, timespanMs) => total + timespanMs);
+
+        const scriptingTotal = timingByGroupId[taskGroups.scriptEvaluation.id] || 0;
+        const layoutTotal = timingByGroupId[taskGroups.styleLayout.id] || 0;
+        const renderTotal = timingByGroupId[taskGroups.paintCompositeRender.id] || 0;
+
+        results.push({
+          url: url,
+          total: totalExecutionTimeForURL,
+          scripting: scriptingTotal,
+          layout: layoutTotal,
+          render: renderTotal,
+        });
+      }
+
+      const filteredResults = results
+        .filter(result => result.total > TASK_THRESHOLD)
+        .sort((a, b) => b.total - a.total);
+
+      items.push({
+        phase: str_(UIStrings[/** @type {keyof UIStrings} */ (phaseName)]),
+        total: (phaseTimes.endTs - phaseTimes.startTs) / 1000,
+        subItems: {
+          type: 'subitems',
+          items: filteredResults,
+        },
+      });
+    }
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      /* eslint-disable max-len */
+      {key: 'phase', itemType: 'text', subItemsHeading: {key: 'url', itemType: 'url'}, text: 'Phase'},
+      {key: 'total', itemType: 'ms', subItemsHeading: {key: 'total', granularity: 1, itemType: 'ms'}, granularity: 1, text: 'Total time'},
+      {key: null, itemType: 'ms', subItemsHeading: {key: 'scripting', granularity: 1, itemType: 'ms'}, text: 'Script evaluation'},
+      {key: null, itemType: 'ms', subItemsHeading: {key: 'layout', granularity: 1, itemType: 'ms'}, text: taskGroups.styleLayout.label},
+      {key: null, itemType: 'ms', subItemsHeading: {key: 'render', granularity: 1, itemType: 'ms'}, text: taskGroups.paintCompositeRender.label},
+      /* eslint-enable max-len */
+    ];
+
+    return {
+      table: Audit.makeTableDetails(headings, items),
+      phases,
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts['TraceElements']} traceElements
+   * @return {LH.Audit.Details.Table | undefined}
+   */
+  static getTraceElementTable(traceElements) {
+    const responsivenessElement = traceElements.find(el => el.traceEventType === 'responsiveness');
+    if (!responsivenessElement) return;
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'node', itemType: 'node', text: str_(UIStrings.eventTarget)},
+    ];
+    const elementItems = [{node: Audit.makeNodeItem(responsivenessElement.node)}];
+
+    return Audit.makeTableDetails(headings, elementItems);
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const {settings} = context;
+    // TODO: responsiveness isn't yet supported by lantern.
+    if (settings.throttlingMethod === 'simulate') {
+      return {score: null, notApplicable: true};
+    }
+
+    const trace = artifacts.traces[WorkDuringInteraction.DEFAULT_PASS];
+    const metricData = {trace, settings};
+    const interactionEvent = await ComputedResponsivenes.request(metricData, context);
+    // If no interaction, diagnostic audit is n/a.
+    if (interactionEvent === null) {
+      return {score: null, notApplicable: true};
+    }
+    // TODO: remove workaround once 103.0.5052.0 is sufficiently released.
+    if (interactionEvent.name === 'FallbackTiming') {
+      throw new LHError(
+        LHError.errors.UNSUPPORTED_OLD_CHROME,
+        {featureName: 'detailed EventTiming trace events'}
+      );
+    }
+
+    const auditDetailsItems = [];
+
+    const traceElementItem = WorkDuringInteraction.getTraceElementTable(artifacts.TraceElements);
+    if (traceElementItem) auditDetailsItems.push(traceElementItem);
+
+    const devtoolsLog = artifacts.devtoolsLogs[WorkDuringInteraction.DEFAULT_PASS];
+    // Network records will usually be empty for timespans.
+    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
+    const processedTrace = await ProcessedTrace.request(trace, context);
+    const {table: breakdownTable, phases} = WorkDuringInteraction.getThreadBreakdownTable(
+        interactionEvent, trace, processedTrace, networkRecords);
+    auditDetailsItems.push(breakdownTable);
+
+    const interactionType = interactionEvent.args.data.type;
+    auditDetailsItems.push({
+      type: /** @type {const} */ ('debugdata'),
+      interactionType,
+      phases,
+    });
+
+    const duration = interactionEvent.args.data.duration;
+    const displayValue = str_(UIStrings.displayValue, {timeInMs: duration, interactionType});
+    return {
+      score: duration < inpThresholds.p10 ? 1 : 0,
+      displayValue,
+      details: {
+        type: 'list',
+        items: auditDetailsItems,
+      },
+    };
+  }
+}
+
+module.exports = WorkDuringInteraction;
+module.exports.UIStrings = UIStrings;

package/lighthouse-core/computed/metrics/responsiveness.js

@@ -25,11 +25,14 @@
  * @property {number} interactionId
  */
 /** @typedef {LH.Trace.AsyncEvent & {name: 'EventTiming', args: {data: EventTimingData}}} EventTimingEvent */
-
+/**
+ * A fallback EventTiming placeholder, used if updated EventTiming events are not available.
+ * TODO: Remove once 103.0.5052.0 is sufficiently released.
+ * @typedef {{name: 'FallbackTiming', duration: number}} FallbackTimingEvent
+ */
 
 const makeComputedArtifact = require('../computed-artifact.js');
 const ProcessedTrace = require('../processed-trace.js');
-const LHError = require('../../lib/lh-error.js');
 
 const KEYBOARD_EVENTS = new Set(['keydown', 'keypress', 'keyup']);
 const CLICK_TAP_DRAG_EVENTS = new Set([
@@ -77,7 +80,7 @@ class Responsiveness {
    * one interaction had this duration by returning the first found.
    * @param {ResponsivenessEvent} responsivenessEvent
    * @param {LH.Trace} trace
-   * @return {EventTimingEvent}
+   * @return {EventTimingEvent|FallbackTimingEvent}
    */
   static findInteractionEvent(responsivenessEvent, {traceEvents}) {
     const candidates = traceEvents.filter(/** @return {evt is EventTimingEvent} */ evt => {
@@ -85,12 +88,12 @@ class Responsiveness {
       return evt.name === 'EventTiming' && evt.ph !== 'e';
     });
 
-    if (candidates.length && !candidates[0].args.data.frame) {
+    if (candidates.length && !candidates.some(candidate => candidate.args.data?.frame)) {
       // Full EventTiming data added in https://crrev.com/c/3632661
-      throw new LHError(
-        LHError.errors.UNSUPPORTED_OLD_CHROME,
-        {featureName: 'detailed EventTiming trace events'}
-      );
+      return {
+        name: 'FallbackTiming',
+        duration: responsivenessEvent.args.data.maxDuration,
+      };
     }
 
     const {maxDuration, interactionType} = responsivenessEvent.args.data;
@@ -131,7 +134,7 @@ class Responsiveness {
   /**
    * @param {{trace: LH.Trace, settings: Immutable<LH.Config.Settings>}} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<EventTimingEvent|null>}
+   * @return {Promise<EventTimingEvent|FallbackTimingEvent|null>}
    */
   static async compute_(data, context) {
     const {settings, trace} = data;

package/lighthouse-core/config/metrics-to-audits.js

@@ -48,9 +48,14 @@ const clsRelevantAudits = [
   // 'preload-fonts', // actually in BP, rather than perf
 ];
 
+const inpRelevantAudits = [
+  'work-during-interaction',
+];
+
 module.exports = {
   fcpRelevantAudits,
   lcpRelevantAudits,
   tbtRelevantAudits,
   clsRelevantAudits,
+  inpRelevantAudits,
 };

package/lighthouse-core/fraggle-rock/config/default-config.js

@@ -6,19 +6,23 @@
 'use strict';
 
 const legacyDefaultConfig = require('../../config/default-config.js');
+const m2a = require('../../config/metrics-to-audits.js');
 const {deepClone} = require('../../config/config-helpers.js');
 
 /** @type {LH.Config.AuditJson[]} */
 const frAudits = [
   'byte-efficiency/uses-responsive-images-snapshot',
   'metrics/experimental-interaction-to-next-paint',
+  'work-during-interaction',
 ];
 
 /** @type {Record<string, LH.Config.AuditRefJson[]>} */
 const frCategoryAuditRefExtensions = {
   'performance': [
     {id: 'uses-responsive-images-snapshot', weight: 0},
-    {id: 'experimental-interaction-to-next-paint', weight: 0, group: 'metrics', acronym: 'INP'},
+    {id: 'experimental-interaction-to-next-paint', weight: 0, group: 'metrics', acronym: 'INP',
+      relevantAudits: m2a.inpRelevantAudits},
+    {id: 'work-during-interaction', weight: 0},
   ],
 };
 
@@ -100,7 +104,6 @@ const defaultConfig = {
     {id: artifacts.EmbeddedContent, gatherer: 'seo/embedded-content'},
     {id: artifacts.FontSize, gatherer: 'seo/font-size'},
     {id: artifacts.Inputs, gatherer: 'inputs'},
-    {id: artifacts.FullPageScreenshot, gatherer: 'full-page-screenshot'},
     {id: artifacts.GlobalListeners, gatherer: 'global-listeners'},
     {id: artifacts.IFrameElements, gatherer: 'iframe-elements'},
     {id: artifacts.ImageElements, gatherer: 'image-elements'},
@@ -130,6 +133,9 @@ const defaultConfig = {
     // Artifact copies are renamed for compatibility with legacy artifacts.
     {id: artifacts.devtoolsLogs, gatherer: 'devtools-log-compat'},
     {id: artifacts.traces, gatherer: 'trace-compat'},
+
+    // FullPageScreenshot comes at the very end so all other node analysis is captured.
+    {id: artifacts.FullPageScreenshot, gatherer: 'full-page-screenshot'},
   ],
   navigations: [
     {

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

@@ -22,6 +22,7 @@ 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[]}[]}} TraceElementData */
 
@@ -142,6 +143,23 @@ class TraceElements extends FRGatherer {
     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
@@ -237,14 +255,15 @@ class TraceElements extends FRGatherer {
 
     const lcpNodeId = largestContentfulPaintEvt?.args?.data?.nodeId;
     const clsNodeData = TraceElements.getTopLayoutShiftElements(mainThreadEvents);
-    const animatedElementData =
-      await this.getAnimatedElements(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', lcpNodeId ? [{nodeId: lcpNodeId}] : []],
       ['layout-shift', clsNodeData],
       ['animation', animatedElementData],
+      ['responsiveness', responsivenessElementData ? [responsivenessElementData] : []],
     ]);
 
     const traceElements = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lighthouse",
-  "version": "9.5.0-dev.20220509",
+  "version": "9.5.0-dev.20220512",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./lighthouse-core/index.js",
   "bin": {

package/report/assets/styles.css

@@ -300,6 +300,9 @@
   /* This is normally the height of the topbar, but we want it to stick to the top of our scroll container .lh-container` */
   top: 0;
 }
+.lh-devtools .lh-element-screenshot__overlay {
+  position: absolute;
+}
 
 @keyframes fadeIn {
   0% { opacity: 0;}
@@ -1061,8 +1064,8 @@
 }
 
 /* Report */
-.lh-list > div:not(:last-child) {
-  padding-bottom: 20px;
+.lh-list > :not(:last-child) {
+  margin-bottom: calc(var(--default-padding) * 2);
 }
 
 .lh-header-container {

package/report/renderer/api.js

@@ -4,7 +4,6 @@
  * 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 {DOM} from '../renderer/dom.js';
 import {ReportRenderer} from '../renderer/report-renderer.js';
 import {ReportUIFeatures} from '../renderer/report-ui-features.js';