From 29b340934f04fd331c49aada050974b4cd1e95cb Mon Sep 17 00:00:00 2001
From: Patrick Hulce <patrick.hulce@gmail.com>
Date: Thu, 19 Apr 2018 10:44:50 -0700
Subject: [PATCH 1/5] core: merge render blocking audits to lantern

---
 lighthouse-cli/test/smokehouse/dbw-config.js  |   3 +-
 .../dobetterweb/dbw-expectations.js           |  28 +--
 .../test/smokehouse/offline-config.js         |   3 +-
 .../offline-local/offline-expectations.js     |   5 +-
 .../byte-efficiency/byte-efficiency-audit.js  |   3 +-
 .../dobetterweb/link-blocking-first-paint.js  | 120 -------------
 .../dobetterweb/render-blocking-resources.js  | 170 ++++++++++++++++++
 .../script-blocking-first-paint.js            |  46 -----
 lighthouse-core/config/default-config.js      |   6 +-
 .../gather/computed/metrics/lantern-metric.js |   5 +-
 .../lib/dependency-graph/network-node.js      |   5 +-
 .../byte-efficiency-audit-test.js             |  27 +++
 .../link-blocking-first-paint-test.js         |  89 ---------
 .../render-blocking-resources-test.js         |  83 +++++++++
 .../script-blocking-first-paint-test.js       |  72 --------
 15 files changed, 296 insertions(+), 369 deletions(-)
 delete mode 100644 lighthouse-core/audits/dobetterweb/link-blocking-first-paint.js
 create mode 100644 lighthouse-core/audits/dobetterweb/render-blocking-resources.js
 delete mode 100644 lighthouse-core/audits/dobetterweb/script-blocking-first-paint.js
 delete mode 100644 lighthouse-core/test/audits/dobetterweb/link-blocking-first-paint-test.js
 create mode 100644 lighthouse-core/test/audits/dobetterweb/render-blocking-resources-test.js
 delete mode 100644 lighthouse-core/test/audits/dobetterweb/script-blocking-first-paint-test.js

diff --git a/lighthouse-cli/test/smokehouse/dbw-config.js b/lighthouse-cli/test/smokehouse/dbw-config.js
index 2bd795cfdea8..4f98d07e94c1 100644
--- a/lighthouse-cli/test/smokehouse/dbw-config.js
+++ b/lighthouse-cli/test/smokehouse/dbw-config.js
@@ -16,8 +16,7 @@ module.exports = {
     ],
     onlyAudits: [
       'dom-size',
-      'link-blocking-first-paint',
-      'script-blocking-first-paint',
+      'render-blocking-resources',
       'errors-in-console',
     ],
   },
diff --git a/lighthouse-cli/test/smokehouse/dobetterweb/dbw-expectations.js b/lighthouse-cli/test/smokehouse/dobetterweb/dbw-expectations.js
index bec4bbb19801..f51764d97b96 100644
--- a/lighthouse-cli/test/smokehouse/dobetterweb/dbw-expectations.js
+++ b/lighthouse-cli/test/smokehouse/dobetterweb/dbw-expectations.js
@@ -67,22 +67,6 @@ module.exports = [
       'geolocation-on-start': {
         score: 0,
       },
-      'link-blocking-first-paint': {
-        score: 0,
-        rawValue: '<3000',
-        extendedInfo: {
-          value: {
-            results: {
-              length: 5,
-            },
-          },
-        },
-        details: {
-          items: {
-            length: 5,
-          },
-        },
-      },
       'no-document-write': {
         score: 0,
         extendedInfo: {
@@ -126,18 +110,12 @@ module.exports = [
       'notification-on-start': {
         score: 0,
       },
-      'script-blocking-first-paint': {
+      'render-blocking-resources': {
         score: '<1',
-        extendedInfo: {
-          value: {
-            results: {
-              length: 2,
-            },
-          },
-        },
+        rawValue: '>100',
         details: {
           items: {
-            length: 2,
+            length: 7,
           },
         },
       },
diff --git a/lighthouse-cli/test/smokehouse/offline-config.js b/lighthouse-cli/test/smokehouse/offline-config.js
index 982ea0973edb..01a263ae96e2 100644
--- a/lighthouse-cli/test/smokehouse/offline-config.js
+++ b/lighthouse-cli/test/smokehouse/offline-config.js
@@ -23,8 +23,7 @@ module.exports = {
       'without-javascript',
       'user-timings',
       'critical-request-chains',
-      'link-blocking-first-paint',
-      'script-blocking-first-paint',
+      'render-blocking-resources',
       'webapp-install-banner',
       'splash-screen',
       'themed-omnibox',
diff --git a/lighthouse-cli/test/smokehouse/offline-local/offline-expectations.js b/lighthouse-cli/test/smokehouse/offline-local/offline-expectations.js
index 63f7c9a4f049..2866857a0d4e 100644
--- a/lighthouse-cli/test/smokehouse/offline-local/offline-expectations.js
+++ b/lighthouse-cli/test/smokehouse/offline-local/offline-expectations.js
@@ -30,7 +30,7 @@ module.exports = [
       'geolocation-on-start': {
         score: 1,
       },
-      'link-blocking-first-paint': {
+      'render-blocking-resources': {
         score: 1,
       },
       'no-document-write': {
@@ -42,9 +42,6 @@ module.exports = [
       'no-websql': {
         score: 1,
       },
-      'script-blocking-first-paint': {
-        score: 1,
-      },
       'uses-passive-event-listeners': {
         score: 1,
       },
diff --git a/lighthouse-core/audits/byte-efficiency/byte-efficiency-audit.js b/lighthouse-core/audits/byte-efficiency/byte-efficiency-audit.js
index 03171611ef6d..9e7a1519db6e 100644
--- a/lighthouse-core/audits/byte-efficiency/byte-efficiency-audit.js
+++ b/lighthouse-core/audits/byte-efficiency/byte-efficiency-audit.js
@@ -78,8 +78,7 @@ class UnusedBytes extends Audit {
     const settings = context && context.settings || {};
     const simulatorOptions = {
       devtoolsLog,
-      throttlingMethod: settings.throttlingMethod,
-      throttling: settings.throttling,
+      settings,
     };
 
     return artifacts
diff --git a/lighthouse-core/audits/dobetterweb/link-blocking-first-paint.js b/lighthouse-core/audits/dobetterweb/link-blocking-first-paint.js
deleted file mode 100644
index 6deecbd6dd66..000000000000
--- a/lighthouse-core/audits/dobetterweb/link-blocking-first-paint.js
+++ /dev/null
@@ -1,120 +0,0 @@
-/**
- * @license Copyright 2016 Google Inc. 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 Audit a page to see if it does not use <link> that block first paint.
- */
-
-'use strict';
-
-const Audit = require('../audit');
-const Util = require('../../report/v2/renderer/util.js');
-const ByteEfficiencyAudit = require('../byte-efficiency/byte-efficiency-audit');
-
-// Because of the way we detect blocking stylesheets, asynchronously loaded
-// CSS with link[rel=preload] and an onload handler (see https://github.com/filamentgroup/loadCSS)
-// can be falsely flagged as blocking. Therefore, ignore stylesheets that loaded fast enough
-// to possibly be non-blocking (and they have minimal impact anyway).
-const LOAD_THRESHOLD_IN_MS = 50;
-
-class LinkBlockingFirstPaintAudit extends Audit {
-  /**
-   * @return {!AuditMeta}
-   */
-  static get meta() {
-    return {
-      name: 'link-blocking-first-paint',
-      description: 'Reduce render-blocking stylesheets',
-      informative: true,
-      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
-      helpText: 'External stylesheets are blocking the first paint of your page. Consider ' +
-          'delivering critical CSS via `<style>` tags and deferring non-critical ' +
-          'styles. [Learn more](https://developers.google.com/web/tools/lighthouse/audits/blocking-resources).',
-      requiredArtifacts: ['TagsBlockingFirstPaint', 'traces'],
-    };
-  }
-
-  /**
-   * @param {!Artifacts} artifacts
-   * @param {string} tagFilter The tagName to filter on
-   * @param {number=} endTimeMax The trace milisecond timestamp that offending tags must have ended
-   *    before (typically first contentful paint).
-   * @param {number=} loadDurationThreshold Filter to resources that took at least this
-   *    many milliseconds to load.
-   * @return {!AuditResult} The object to pass to `generateAuditResult`
-   */
-  static computeAuditResultForTags(artifacts, tagFilter, endTimeMax = Infinity,
-      loadDurationThreshold = 0) {
-    const artifact = artifacts.TagsBlockingFirstPaint;
-
-    const filtered = artifact.filter(item => {
-      return item.tag.tagName === tagFilter &&
-        (item.endTime - item.startTime) * 1000 >= loadDurationThreshold &&
-        item.endTime * 1000 < endTimeMax;
-    });
-
-    const startTime = filtered.length === 0 ? 0 :
-        filtered.reduce((t, item) => Math.min(t, item.startTime), Number.MAX_VALUE);
-    let endTime = 0;
-
-    const results = filtered
-      .map(item => {
-        endTime = Math.max(item.endTime, endTime);
-
-        return {
-          url: item.tag.url,
-          totalBytes: item.transferSize,
-          wastedMs: (item.endTime - startTime) * 1000,
-        };
-      })
-      .sort((a, b) => b.wastedMs - a.wastedMs);
-
-    const rawDelayTime = Math.round((endTime - startTime) * 1000);
-    const delayTime = Util.formatMilliseconds(rawDelayTime, 1);
-    let displayValue = '';
-    if (results.length > 1) {
-      displayValue = `${results.length} resources delayed first paint by ${delayTime}`;
-    } else if (results.length === 1) {
-      displayValue = `${results.length} resource delayed first paint by ${delayTime}`;
-    }
-
-    const headings = [
-      {key: 'url', itemType: 'url', text: 'URL'},
-      {key: 'totalBytes', itemType: 'bytes', displayUnit: 'kb', granularity: 0.01,
-        text: 'Size (KB)'},
-      {key: 'wastedMs', itemType: 'ms', text: 'Delayed Paint By (ms)', granularity: 1},
-    ];
-
-    const summary = {wastedMs: rawDelayTime};
-    const details = Audit.makeTableDetails(headings, results, summary);
-
-    return {
-      displayValue,
-      score: ByteEfficiencyAudit.scoreForWastedMs(rawDelayTime),
-      rawValue: rawDelayTime,
-      extendedInfo: {
-        value: {
-          results,
-        },
-      },
-      details,
-    };
-  }
-
-  /**
-   * @param {!Artifacts} artifacts
-   * @return {!AuditResult}
-   */
-  static audit(artifacts) {
-    const trace = artifacts.traces[Audit.DEFAULT_PASS];
-    return artifacts.requestTraceOfTab(trace).then(traceOfTab => {
-      const fcpTsInMs = traceOfTab.timestamps.firstContentfulPaint / 1000;
-      return this.computeAuditResultForTags(artifacts, 'LINK', fcpTsInMs, LOAD_THRESHOLD_IN_MS);
-    });
-  }
-}
-
-module.exports = LinkBlockingFirstPaintAudit;
diff --git a/lighthouse-core/audits/dobetterweb/render-blocking-resources.js b/lighthouse-core/audits/dobetterweb/render-blocking-resources.js
new file mode 100644
index 000000000000..8f8a482bb081
--- /dev/null
+++ b/lighthouse-core/audits/dobetterweb/render-blocking-resources.js
@@ -0,0 +1,170 @@
+/**
+ * @license Copyright 2018 Google Inc. 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 Audit a page to see if it does have resources that are blocking first paint
+ */
+
+'use strict';
+
+const Audit = require('../audit');
+const Node = require('../../lib/dependency-graph/node');
+const CPUNode = require('../../lib/dependency-graph/cpu-node');
+const ByteEfficiencyAudit = require('../byte-efficiency/byte-efficiency-audit');
+
+// Because of the way we detect blocking stylesheets, asynchronously loaded
+// CSS with link[rel=preload] and an onload handler (see https://github.com/filamentgroup/loadCSS)
+// can be falsely flagged as blocking. Therefore, ignore stylesheets that loaded fast enough
+// to possibly be non-blocking (and they have minimal impact anyway).
+const MINIMUM_DOWNLOAD_TIME_IN_MS = 50;
+
+const keyByUrl = arr => arr.reduce((map, node) => {
+  map[node.record && node.record.url] = node;
+  return map;
+}, {});
+
+class RenderBlockingResources extends Audit {
+  /**
+   * @return {!AuditMeta}
+   */
+  static get meta() {
+    return {
+      name: 'render-blocking-resources',
+      description: 'Reduce render-blocking resources',
+      informative: true,
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      helpText: 'Resources are blocking the first paint of your page. Consider ' +
+          'delivering critical JS/CSS inline and deferring all non-critical ' +
+          'JS/styles. [Learn more](https://developers.google.com/web/tools/lighthouse/audits/blocking-resources).',
+      requiredArtifacts: ['TagsBlockingFirstPaint', 'traces'],
+    };
+  }
+
+  /**
+   * @param {Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   */
+  static async computeResults(artifacts, context) {
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const simulatorData = {devtoolsLog, settings: context.settings};
+    const traceOfTab = await artifacts.requestTraceOfTab(trace);
+    const simulator = await artifacts.requestLoadSimulator(simulatorData);
+
+    const metricSettings = {throttlingMethod: 'simulate'};
+    const metricComputationData = {trace, devtoolsLog, simulator, settings: metricSettings};
+    const fcpSimulation = await artifacts.requestFirstContentfulPaint(metricComputationData);
+    const fcpTsInMs = traceOfTab.timestamps.firstContentfulPaint / 1000;
+
+    const nodeTimingMap = fcpSimulation.pessimisticEstimate.nodeTiming;
+    const nodesByUrl = keyByUrl(Array.from(nodeTimingMap.keys()));
+
+    const results = [];
+    for (const resource of artifacts.TagsBlockingFirstPaint) {
+      if (resource.endTime * 1000 > fcpTsInMs) continue;
+      if ((resource.endTime - resource.startTime) * 1000 < MINIMUM_DOWNLOAD_TIME_IN_MS) continue;
+
+      const node = nodesByUrl[resource.tag.url];
+      // TODO(phulce): beacon these occurences to Sentry to improve FCP graph
+      if (!node) continue;
+
+      const nodeTiming = nodeTimingMap.get(node);
+      results.push({
+        url: resource.tag.url,
+        totalBytes: resource.transferSize,
+        wastedMs: nodeTiming.endTime - nodeTiming.startTime,
+      });
+    }
+
+    if (!results.length) {
+      return {results, wastedMs: 0};
+    }
+
+    const wastedMs = RenderBlockingResources.estimateSavingsFromInlining(
+      simulator,
+      fcpSimulation.pessimisticGraph,
+      fcpSimulation.pessimisticEstimate.timeInMs
+    );
+    return {results, wastedMs};
+  }
+
+  /**
+   * @param {Simulator} simulator
+   * @param {Node} fcpGraph
+   * @return {number}
+   */
+  static estimateSavingsFromInlining(simulator, fcpGraph) {
+    const originalEstimate = simulator.simulate(fcpGraph).timeInMs;
+
+    let earliestCpuTs = Infinity;
+    let totalChildCpuTime = 0;
+    let totalChildNetworkBytes = 0;
+    const graphWithoutChildren = fcpGraph.cloneWithRelationships(node => {
+      // Node is root node, this is the only one we're keeping
+      if (node === fcpGraph) return true;
+
+      // Node is network node, we're dropping and pretending we're inlining
+      if (node.type === Node.TYPES.NETWORK) {
+        totalChildNetworkBytes += node.record.transferSize;
+        return false;
+      }
+
+      // Node is CPU node we're dropping and merging into one mega CPU task
+      if (node.type === Node.TYPES.CPU) {
+        earliestCpuTs = node.event.ts;
+        totalChildCpuTime += node.event.dur;
+        return false;
+      }
+    });
+
+    if (totalChildCpuTime) {
+      const fakeChildEvents = [];
+      const fakeEvent = {pid: 1, tid: 1, ts: earliestCpuTs, dur: totalChildCpuTime};
+      const fakeCpuNode = new CPUNode(fakeEvent, fakeChildEvents);
+      graphWithoutChildren.addDependent(fakeCpuNode);
+    }
+
+    graphWithoutChildren.record._transferSize += totalChildNetworkBytes;
+    const estimateAfterInline = simulator.simulate(graphWithoutChildren).timeInMs;
+    graphWithoutChildren.record._transferSize -= totalChildNetworkBytes;
+    return Math.max(originalEstimate - estimateAfterInline, 0);
+  }
+
+  /**
+   * @param {!Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {!AuditResult}
+   */
+  static async audit(artifacts, context) {
+    const {results, wastedMs} = await RenderBlockingResources.computeResults(artifacts, context);
+
+    let displayValue = '';
+    if (results.length > 1) {
+      displayValue = `${results.length} resources delayed first paint by ${wastedMs}ms`;
+    } else if (results.length === 1) {
+      displayValue = `${results.length} resource delayed first paint by ${wastedMs}ms`;
+    }
+
+    const headings = [
+      {key: 'url', itemType: 'url', text: 'URL'},
+      {key: 'totalBytes', itemType: 'bytes', displayUnit: 'kb', granularity: 0.01,
+        text: 'Size (KB)'},
+      {key: 'wastedMs', itemType: 'ms', text: 'Download Time (ms)', granularity: 1},
+    ];
+
+    const summary = {wastedMs};
+    const details = Audit.makeTableDetails(headings, results, summary);
+
+    return {
+      displayValue,
+      score: ByteEfficiencyAudit.scoreForWastedMs(wastedMs),
+      rawValue: wastedMs,
+      details,
+    };
+  }
+}
+
+module.exports = RenderBlockingResources;
diff --git a/lighthouse-core/audits/dobetterweb/script-blocking-first-paint.js b/lighthouse-core/audits/dobetterweb/script-blocking-first-paint.js
deleted file mode 100644
index c139161c2e80..000000000000
--- a/lighthouse-core/audits/dobetterweb/script-blocking-first-paint.js
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- * @license Copyright 2016 Google Inc. 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 Audit a page to see if it does not use sync <script> in <head>.
- */
-
-'use strict';
-
-const Audit = require('../audit');
-const LinkBlockingFirstPaintAudit = require('./link-blocking-first-paint');
-
-class ScriptBlockingFirstPaint extends Audit {
-  /**
-   * @return {!AuditMeta}
-   */
-  static get meta() {
-    return {
-      name: 'script-blocking-first-paint',
-      description: 'Reduce render-blocking scripts',
-      informative: true,
-      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
-      helpText: 'Script elements are blocking the first paint of your page. Consider inlining ' +
-          'critical scripts and deferring non-critical ones. ' +
-          '[Learn more](https://developers.google.com/web/tools/lighthouse/audits/blocking-resources).',
-      requiredArtifacts: ['TagsBlockingFirstPaint', 'traces'],
-    };
-  }
-
-  /**
-   * @param {!Artifacts} artifacts
-   * @return {!AuditResult}
-   */
-  static audit(artifacts) {
-    const trace = artifacts.traces[Audit.DEFAULT_PASS];
-    return artifacts.requestTraceOfTab(trace).then(traceOfTab => {
-      const fcpTsInMs = traceOfTab.timestamps.firstContentfulPaint / 1000;
-      return LinkBlockingFirstPaintAudit.computeAuditResultForTags(artifacts, 'SCRIPT', fcpTsInMs);
-    });
-  }
-}
-
-module.exports = ScriptBlockingFirstPaint;
diff --git a/lighthouse-core/config/default-config.js b/lighthouse-core/config/default-config.js
index 037d94514ace..a5f4f7eb4c13 100644
--- a/lighthouse-core/config/default-config.js
+++ b/lighthouse-core/config/default-config.js
@@ -163,14 +163,13 @@ module.exports = {
     'dobetterweb/dom-size',
     'dobetterweb/external-anchors-use-rel-noopener',
     'dobetterweb/geolocation-on-start',
-    'dobetterweb/link-blocking-first-paint',
+    'dobetterweb/render-blocking-resources',
     'dobetterweb/no-document-write',
     'dobetterweb/no-mutation-events',
     'dobetterweb/no-vulnerable-libraries',
     'dobetterweb/no-websql',
     'dobetterweb/notification-on-start',
     'dobetterweb/password-inputs-can-be-pasted-into',
-    'dobetterweb/script-blocking-first-paint',
     'dobetterweb/uses-http2',
     'dobetterweb/uses-passive-event-listeners',
     'seo/meta-description',
@@ -270,8 +269,7 @@ module.exports = {
         {id: 'consistently-interactive', weight: 5, group: 'perf-metric'},
         {id: 'speed-index-metric', weight: 1, group: 'perf-metric'},
         {id: 'estimated-input-latency', weight: 1, group: 'perf-metric'},
-        {id: 'link-blocking-first-paint', weight: 0, group: 'perf-hint'},
-        {id: 'script-blocking-first-paint', weight: 0, group: 'perf-hint'},
+        {id: 'render-blocking-resources', weight: 0, group: 'perf-hint'},
         {id: 'uses-responsive-images', weight: 0, group: 'perf-hint'},
         {id: 'offscreen-images', weight: 0, group: 'perf-hint'},
         {id: 'unminified-css', weight: 0, group: 'perf-hint'},
diff --git a/lighthouse-core/gather/computed/metrics/lantern-metric.js b/lighthouse-core/gather/computed/metrics/lantern-metric.js
index c637d64c878e..a056ea26870a 100644
--- a/lighthouse-core/gather/computed/metrics/lantern-metric.js
+++ b/lighthouse-core/gather/computed/metrics/lantern-metric.js
@@ -66,7 +66,7 @@ class LanternMetricArtifact extends ComputedArtifact {
   }
 
   /**
-   * @param {{trace: Object, devtoolsLog: Object, settings: LH.Config.Settings}} data
+   * @param {{trace: Object, devtoolsLog: Object, settings: LH.Config.Settings, simulator?: Simulator}} data
    * @param {Object} artifacts
    * @param {any=} extras
    * @return {Promise<LH.Artifacts.LanternMetric>}
@@ -76,7 +76,8 @@ class LanternMetricArtifact extends ComputedArtifact {
     const graph = await artifacts.requestPageDependencyGraph({trace, devtoolsLog});
     const traceOfTab = await artifacts.requestTraceOfTab(trace);
     /** @type {Simulator} */
-    const simulator = await artifacts.requestLoadSimulator({devtoolsLog, settings});
+    const simulator = data.simulator ||
+        await artifacts.requestLoadSimulator({devtoolsLog, settings});
 
     const optimisticGraph = this.getOptimisticGraph(graph, traceOfTab);
     const pessimisticGraph = this.getPessimisticGraph(graph, traceOfTab);
diff --git a/lighthouse-core/lib/dependency-graph/network-node.js b/lighthouse-core/lib/dependency-graph/network-node.js
index f55e80a5995a..b98c666130d0 100644
--- a/lighthouse-core/lib/dependency-graph/network-node.js
+++ b/lighthouse-core/lib/dependency-graph/network-node.js
@@ -65,7 +65,10 @@ class NetworkNode extends Node {
   hasRenderBlockingPriority() {
     const priority = this._record.priority();
     const isScript = this._record._resourceType === WebInspector.resourceTypes.Script;
-    return priority === 'VeryHigh' || (priority === 'High' && isScript);
+    const isDocument = this._record._resourceType === WebInspector.resourceTypes.Document;
+    const isBlockingScript = priority === 'High' && isScript;
+    const isBlockingHtmlImport = priority === 'High' && isDocument;
+    return priority === 'VeryHigh' || isBlockingScript || isBlockingHtmlImport;
   }
 
   /**
diff --git a/lighthouse-core/test/audits/byte-efficiency/byte-efficiency-audit-test.js b/lighthouse-core/test/audits/byte-efficiency/byte-efficiency-audit-test.js
index b4957763c817..4191b9019c83 100644
--- a/lighthouse-core/test/audits/byte-efficiency/byte-efficiency-audit-test.js
+++ b/lighthouse-core/test/audits/byte-efficiency/byte-efficiency-audit-test.js
@@ -198,4 +198,31 @@ describe('Byte efficiency base audit', () => {
 
     assert.equal(result.rawValue, 300);
   });
+
+  it('should create load simulator with the specified settings', async () => {
+    class MockAudit extends ByteEfficiencyAudit {
+      static audit_(artifacts, records) {
+        return {
+          results: records.map(record => ({url: record.url, wastedBytes: record.transferSize})),
+          headings: [],
+        };
+      }
+    }
+
+    const artifacts = Runner.instantiateComputedArtifacts();
+    artifacts.traces = {defaultPass: trace};
+    artifacts.devtoolsLogs = {defaultPass: devtoolsLog};
+
+    const modestThrottling = {rttMs: 150, throughputKbps: 1000, cpuSlowdownMultiplier: 2};
+    const ultraSlowThrottling = {rttMs: 150, throughputKbps: 100, cpuSlowdownMultiplier: 8};
+    let settings = {throttlingMethod: 'simulate', throttling: modestThrottling};
+    let result = await MockAudit.audit(artifacts, {settings});
+    // expect modest savings
+    assert.equal(result.rawValue, 800);
+
+    settings = {throttlingMethod: 'simulate', throttling: ultraSlowThrottling};
+    result = await MockAudit.audit(artifacts, {settings});
+    // expect lots of savings
+    assert.equal(result.rawValue, 22350);
+  });
 });
diff --git a/lighthouse-core/test/audits/dobetterweb/link-blocking-first-paint-test.js b/lighthouse-core/test/audits/dobetterweb/link-blocking-first-paint-test.js
deleted file mode 100644
index 89a153c0f06e..000000000000
--- a/lighthouse-core/test/audits/dobetterweb/link-blocking-first-paint-test.js
+++ /dev/null
@@ -1,89 +0,0 @@
-/**
- * @license Copyright 2016 Google Inc. 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 LinkBlockingFirstPaintAudit =
-    require('../../../audits/dobetterweb/link-blocking-first-paint.js');
-const assert = require('assert');
-const NBSP = '\xa0';
-
-/* eslint-env mocha */
-
-describe('Link Block First Paint audit', () => {
-  it('fails when there are links found which block first paint', () => {
-    const linkDetails = {
-      tagName: 'LINK',
-      href: 'http://google.com/css/style.css',
-      url: 'http://google.com/css/style.css',
-      disabled: false,
-      media: '',
-      rel: 'stylesheet',
-    };
-    const timestamps = {firstContentfulPaint: 5600 * 1000};
-    return LinkBlockingFirstPaintAudit.audit({
-      traces: {},
-      requestTraceOfTab: () => Promise.resolve({timestamps}),
-      TagsBlockingFirstPaint: [
-        {
-          tag: linkDetails,
-          transferSize: 100,
-          startTime: 4.9,
-          endTime: 5.1,
-        },
-        {
-          tag: linkDetails,
-          transferSize: 100,
-          startTime: 5,
-          endTime: 5.4,
-        },
-        {
-          tag: linkDetails,
-          transferSize: 100,
-          startTime: 5,
-          endTime: 5.8, // should be ignored for being after FCP
-        },
-        {
-          tag: linkDetails,
-          transferSize: 100,
-          startTime: 5,
-          endTime: 5.8, // should be ignored for being after FCP
-        },
-        {
-          tag: linkDetails,
-          transferSize: 100,
-          startTime: 4.7,
-          endTime: 4.73, // should be ignored for being <50ms
-        },
-        {
-          tag: {tagName: 'SCRIPT'},
-          transferSize: 20,
-          spendTime: 20,
-        },
-      ],
-    }).then(auditResult => {
-      assert.equal(auditResult.rawValue, 500);
-      assert.equal(auditResult.displayValue, `2 resources delayed first paint by 500${NBSP}ms`);
-      const results = auditResult.details.items;
-      assert.equal(results.length, 2);
-      assert.ok(results[0].url.includes('css/style.css'), 'has a url');
-      assert.equal(results[0].totalBytes, 100);
-      assert.equal(results[1].totalBytes, 100);
-      assert.equal(results[0].wastedMs, 500);
-      assert.equal(Math.round(results[1].wastedMs), 200);
-    });
-  });
-
-  it('passes when there are no links found which block first paint', () => {
-    return LinkBlockingFirstPaintAudit.audit({
-      traces: {},
-      requestTraceOfTab: () => Promise.resolve({timestamps: {}}),
-      TagsBlockingFirstPaint: [],
-    }).then(auditResult => {
-      assert.equal(auditResult.rawValue, 0);
-      assert.equal(auditResult.details.items.length, 0);
-    });
-  });
-});
diff --git a/lighthouse-core/test/audits/dobetterweb/render-blocking-resources-test.js b/lighthouse-core/test/audits/dobetterweb/render-blocking-resources-test.js
new file mode 100644
index 000000000000..cc5796aff431
--- /dev/null
+++ b/lighthouse-core/test/audits/dobetterweb/render-blocking-resources-test.js
@@ -0,0 +1,83 @@
+/**
+ * @license Copyright 2018 Google Inc. 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 RenderBlockingResourcesAudit =
+    require('../../../audits/dobetterweb/render-blocking-resources.js');
+
+const mobile3G = require('../../../config/constants').throttling.mobile3G;
+const Runner = require('../../../runner');
+const NetworkNode = require('../../../lib/dependency-graph/network-node');
+const CPUNode = require('../../../lib/dependency-graph/cpu-node');
+const Simulator = require('../../../lib/dependency-graph/simulator/simulator');
+const assert = require('assert');
+
+const trace = require('../../fixtures/traces/progressive-app-m60.json');
+const devtoolsLog = require('../../fixtures/traces/progressive-app-m60.devtools.log.json');
+
+/* eslint-env mocha */
+
+describe('Render blocking resources audit', () => {
+  it('evaluates http2 input correctly', async () => {
+    const artifacts = Object.assign({
+      traces: {defaultPass: trace},
+      devtoolsLogs: {defaultPass: devtoolsLog},
+      TagsBlockingFirstPaint: [
+        {
+          tag: {url: 'https://pwa.rocks/script.js'},
+          transferSize: 621,
+        },
+      ],
+    }, Runner.instantiateComputedArtifacts());
+
+    const settings = {throttlingMethod: 'simulate', throttling: mobile3G};
+    const result = await RenderBlockingResourcesAudit.audit(artifacts, {settings});
+    assert.equal(result.score, 1);
+    assert.equal(result.rawValue, 0);
+  });
+
+  describe('#estimateSavingsFromInlining', () => {
+    const estimate = RenderBlockingResourcesAudit.estimateSavingsFromInlining;
+
+    let requestId = 1;
+    const record = props => {
+      const ret = Object.assign({parsedURL: {}, requestId: requestId++}, props);
+      Object.defineProperty(ret, 'transferSize', {
+        get() {
+          return ret._transferSize;
+        },
+      });
+      return ret;
+    };
+
+    it('computes savings from inling', () => {
+      const serverResponseTimeByOrigin = new Map([['undefined://undefined', 100]]);
+      const simulator = new Simulator({rtt: 1000, serverResponseTimeByOrigin});
+      const documentNode = new NetworkNode(record({_transferSize: 4000}));
+      const styleNode = new NetworkNode(record({_transferSize: 3000}));
+      const scriptNode = new NetworkNode(record({_transferSize: 1000}));
+      const scriptExecution = new CPUNode({dur: 50 * 1000}, []);
+
+      documentNode.addDependent(scriptNode);
+      documentNode.addDependent(styleNode);
+      scriptNode.addDependent(scriptExecution);
+      const result = estimate(simulator, documentNode);
+      // Saving 1000 + 1000 + 100ms for TCP handshake + request/response + server response time
+      assert.equal(result, 2100);
+    });
+
+    it('computes savings from inlining when new RT required', () => {
+      const serverResponseTimeByOrigin = new Map([['undefined://undefined', 100]]);
+      const simulator = new Simulator({rtt: 1000, serverResponseTimeByOrigin});
+      const documentNode = new NetworkNode(record({_transferSize: 10000}));
+      const styleNode = new NetworkNode(record({_transferSize: 13000})); // pushes document over 14KB
+      documentNode.addDependent(styleNode);
+      const result = estimate(simulator, documentNode);
+      // Saving 1000 + 100ms for TCP handshake + server response time, response RT still required
+      assert.equal(result, 1100);
+    });
+  });
+});
diff --git a/lighthouse-core/test/audits/dobetterweb/script-blocking-first-paint-test.js b/lighthouse-core/test/audits/dobetterweb/script-blocking-first-paint-test.js
deleted file mode 100644
index 1130f4adf715..000000000000
--- a/lighthouse-core/test/audits/dobetterweb/script-blocking-first-paint-test.js
+++ /dev/null
@@ -1,72 +0,0 @@
-/**
- * @license Copyright 2016 Google Inc. 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 ScriptBlockingFirstPaintAudit =
-    require('../../../audits/dobetterweb/script-blocking-first-paint.js');
-const assert = require('assert');
-const NBSP = '\xa0';
-
-/* eslint-env mocha */
-
-describe('Script Block First Paint audit', () => {
-  it('fails when there are scripts found which block first paint', () => {
-    const scriptDetails = {
-      tagName: 'SCRIPT',
-      src: 'http://google.com/js/app.js',
-      url: 'http://google.com/js/app.js',
-    };
-    const timestamps = {firstContentfulPaint: 5600 * 1000};
-    return ScriptBlockingFirstPaintAudit.audit({
-      traces: {},
-      requestTraceOfTab: () => Promise.resolve({timestamps}),
-      TagsBlockingFirstPaint: [
-        {
-          tag: scriptDetails,
-          transferSize: 100,
-          startTime: 1,
-          endTime: 1.1,
-        },
-        {
-          tag: scriptDetails,
-          transferSize: 100,
-          startTime: 15, // well after FCP and should be ignored
-          endTime: 15.1,
-        },
-        {
-          tag: scriptDetails,
-          transferSize: 50,
-          startTime: 0.95,
-          endTime: 1,
-        },
-        {
-          tag: {tagName: 'LINK'},
-          transferSize: 110,
-          spendTime: 110,
-        },
-      ],
-    }).then(auditResult => {
-      assert.equal(auditResult.rawValue, 150);
-      assert.equal(auditResult.displayValue, `2 resources delayed first paint by 150${NBSP}ms`);
-      const results = auditResult.details.items;
-      assert.equal(results.length, 2);
-      assert.ok(results[0].url.includes('js/app.js'), 'has a url');
-      assert.equal(Math.round(results[0].wastedMs), 150);
-      assert.equal(Math.round(results[1].wastedMs), 50);
-    });
-  });
-
-  it('passes when there are no scripts found which block first paint', () => {
-    return ScriptBlockingFirstPaintAudit.audit({
-      traces: {},
-      requestTraceOfTab: () => Promise.resolve({timestamps: {}}),
-      TagsBlockingFirstPaint: [],
-    }).then(auditResult => {
-      assert.equal(auditResult.rawValue, 0);
-      assert.equal(auditResult.details.items.length, 0);
-    });
-  });
-});

From 7f449c1d6f12a61eeaf4f5c6b5b6dadb2e565ea9 Mon Sep 17 00:00:00 2001
From: Patrick Hulce <patrick.hulce@gmail.com>
Date: Fri, 20 Apr 2018 16:28:37 -0700
Subject: [PATCH 2/5] option #4

---
 .../render-blocking-resources.js              | 88 +++++++++++--------
 lighthouse-core/config/default-config.js      |  2 +-
 .../render-blocking-resources-test.js         | 81 ++++++++++-------
 3 files changed, 102 insertions(+), 69 deletions(-)
 rename lighthouse-core/audits/{dobetterweb => byte-efficiency}/render-blocking-resources.js (68%)
 rename lighthouse-core/test/audits/{dobetterweb => byte-efficiency}/render-blocking-resources-test.js (58%)

diff --git a/lighthouse-core/audits/dobetterweb/render-blocking-resources.js b/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
similarity index 68%
rename from lighthouse-core/audits/dobetterweb/render-blocking-resources.js
rename to lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
index 8f8a482bb081..a129970b2cf0 100644
--- a/lighthouse-core/audits/dobetterweb/render-blocking-resources.js
+++ b/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
@@ -13,13 +13,14 @@
 const Audit = require('../audit');
 const Node = require('../../lib/dependency-graph/node');
 const CPUNode = require('../../lib/dependency-graph/cpu-node');
-const ByteEfficiencyAudit = require('../byte-efficiency/byte-efficiency-audit');
+const ByteEfficiencyAudit = require('./byte-efficiency-audit');
+const UnusedCSS = require('./unused-css-rules');
 
 // Because of the way we detect blocking stylesheets, asynchronously loaded
 // CSS with link[rel=preload] and an onload handler (see https://github.com/filamentgroup/loadCSS)
 // can be falsely flagged as blocking. Therefore, ignore stylesheets that loaded fast enough
 // to possibly be non-blocking (and they have minimal impact anyway).
-const MINIMUM_DOWNLOAD_TIME_IN_MS = 50;
+const MINIMUM_WASTED_MS = 50;
 
 const keyByUrl = arr => arr.reduce((map, node) => {
   map[node.record && node.record.url] = node;
@@ -33,13 +34,13 @@ class RenderBlockingResources extends Audit {
   static get meta() {
     return {
       name: 'render-blocking-resources',
-      description: 'Reduce render-blocking resources',
+      description: 'Eliminate render-blocking resources',
       informative: true,
       scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
       helpText: 'Resources are blocking the first paint of your page. Consider ' +
           'delivering critical JS/CSS inline and deferring all non-critical ' +
           'JS/styles. [Learn more](https://developers.google.com/web/tools/lighthouse/audits/blocking-resources).',
-      requiredArtifacts: ['TagsBlockingFirstPaint', 'traces'],
+      requiredArtifacts: ['CSSUsage', 'URL', 'TagsBlockingFirstPaint', 'traces'],
     };
   }
 
@@ -53,29 +54,39 @@ class RenderBlockingResources extends Audit {
     const simulatorData = {devtoolsLog, settings: context.settings};
     const traceOfTab = await artifacts.requestTraceOfTab(trace);
     const simulator = await artifacts.requestLoadSimulator(simulatorData);
+    const wastedBytesMap = await RenderBlockingResources.computeWastedCSSBytes(artifacts, context);
 
     const metricSettings = {throttlingMethod: 'simulate'};
     const metricComputationData = {trace, devtoolsLog, simulator, settings: metricSettings};
     const fcpSimulation = await artifacts.requestFirstContentfulPaint(metricComputationData);
     const fcpTsInMs = traceOfTab.timestamps.firstContentfulPaint / 1000;
 
-    const nodeTimingMap = fcpSimulation.pessimisticEstimate.nodeTiming;
+    const nodeTimingMap = fcpSimulation.optimisticEstimate.nodeTiming;
     const nodesByUrl = keyByUrl(Array.from(nodeTimingMap.keys()));
 
     const results = [];
+    const deferredNodeIds = new Set();
     for (const resource of artifacts.TagsBlockingFirstPaint) {
+      // Ignore any resources that finished after observed FCP (they're clearly not render-blocking)
       if (resource.endTime * 1000 > fcpTsInMs) continue;
-      if ((resource.endTime - resource.startTime) * 1000 < MINIMUM_DOWNLOAD_TIME_IN_MS) continue;
 
       const node = nodesByUrl[resource.tag.url];
+      const nodeTiming = nodeTimingMap.get(node);
       // TODO(phulce): beacon these occurences to Sentry to improve FCP graph
       if (!node) continue;
 
-      const nodeTiming = nodeTimingMap.get(node);
+      // Mark this node and all it's dependents as deferrable
+      // TODO(phulce): make this slightly more surgical
+      // i.e. the referenced font asset won't become inlined just because you inline the CSS
+      node.traverse(node => deferredNodeIds.add(node.id));
+
+      const wastedMs = nodeTiming.endTime - nodeTiming.startTime;
+      if (wastedMs < MINIMUM_WASTED_MS) continue;
+
       results.push({
         url: resource.tag.url,
         totalBytes: resource.transferSize,
-        wastedMs: nodeTiming.endTime - nodeTiming.startTime,
+        wastedMs,
       });
     }
 
@@ -85,50 +96,40 @@ class RenderBlockingResources extends Audit {
 
     const wastedMs = RenderBlockingResources.estimateSavingsFromInlining(
       simulator,
-      fcpSimulation.pessimisticGraph,
-      fcpSimulation.pessimisticEstimate.timeInMs
+      fcpSimulation.optimisticGraph,
+      deferredNodeIds,
+      wastedBytesMap
     );
+
     return {results, wastedMs};
   }
 
   /**
    * @param {Simulator} simulator
    * @param {Node} fcpGraph
+   * @param {Set<string>} deferredIds
+   * @param {Map<string, number>} wastedBytesMap
    * @return {number}
    */
-  static estimateSavingsFromInlining(simulator, fcpGraph) {
+  static estimateSavingsFromInlining(simulator, fcpGraph, deferredIds, wastedBytesMap) {
     const originalEstimate = simulator.simulate(fcpGraph).timeInMs;
 
-    let earliestCpuTs = Infinity;
-    let totalChildCpuTime = 0;
     let totalChildNetworkBytes = 0;
     const graphWithoutChildren = fcpGraph.cloneWithRelationships(node => {
-      // Node is root node, this is the only one we're keeping
-      if (node === fcpGraph) return true;
-
-      // Node is network node, we're dropping and pretending we're inlining
-      if (node.type === Node.TYPES.NETWORK) {
-        totalChildNetworkBytes += node.record.transferSize;
-        return false;
+      const willDefer = deferredIds.has(node.id);
+      if (willDefer && node.type === Node.TYPES.NETWORK &&
+          node.record._resourceType === WebInspector.resourceTypes.Stylesheet) {
+        const wastedBytes = wastedBytesMap.get(node.record.url) || 0;
+        totalChildNetworkBytes += node.record._transferSize - wastedBytes;
       }
 
-      // Node is CPU node we're dropping and merging into one mega CPU task
-      if (node.type === Node.TYPES.CPU) {
-        earliestCpuTs = node.event.ts;
-        totalChildCpuTime += node.event.dur;
-        return false;
-      }
+      // Include all nodes that couldn't be deferred
+      return !willDefer;
     });
 
-    if (totalChildCpuTime) {
-      const fakeChildEvents = [];
-      const fakeEvent = {pid: 1, tid: 1, ts: earliestCpuTs, dur: totalChildCpuTime};
-      const fakeCpuNode = new CPUNode(fakeEvent, fakeChildEvents);
-      graphWithoutChildren.addDependent(fakeCpuNode);
-    }
-
     graphWithoutChildren.record._transferSize += totalChildNetworkBytes;
-    const estimateAfterInline = simulator.simulate(graphWithoutChildren).timeInMs;
+    const estimateAfterInlineA = simulator.simulate(graphWithoutChildren);
+    const estimateAfterInline = estimateAfterInlineA.timeInMs;
     graphWithoutChildren.record._transferSize -= totalChildNetworkBytes;
     return Math.max(originalEstimate - estimateAfterInline, 0);
   }
@@ -136,7 +137,24 @@ class RenderBlockingResources extends Audit {
   /**
    * @param {!Artifacts} artifacts
    * @param {LH.Audit.Context} context
-   * @return {!AuditResult}
+   * @return {Map<string, number>}
+   */
+  static async computeWastedCSSBytes(artifacts, context) {
+    const wastedBytesByUrl = new Map();
+    try {
+      const results = await UnusedCSS.audit(artifacts, context);
+      for (const item of results.details.items) {
+        wastedBytesByUrl.set(item.url, item.wastedBytes);
+      }
+    } catch (_) {}
+
+    return wastedBytesByUrl;
+  }
+
+  /**
+   * @param {!Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {AuditResult}
    */
   static async audit(artifacts, context) {
     const {results, wastedMs} = await RenderBlockingResources.computeResults(artifacts, context);
diff --git a/lighthouse-core/config/default-config.js b/lighthouse-core/config/default-config.js
index a5f4f7eb4c13..5b6b97fae8e7 100644
--- a/lighthouse-core/config/default-config.js
+++ b/lighthouse-core/config/default-config.js
@@ -152,6 +152,7 @@ module.exports = {
     'byte-efficiency/uses-long-cache-ttl',
     'byte-efficiency/total-byte-weight',
     'byte-efficiency/offscreen-images',
+    'byte-efficiency/render-blocking-resources',
     'byte-efficiency/unminified-css',
     'byte-efficiency/unminified-javascript',
     'byte-efficiency/unused-css-rules',
@@ -163,7 +164,6 @@ module.exports = {
     'dobetterweb/dom-size',
     'dobetterweb/external-anchors-use-rel-noopener',
     'dobetterweb/geolocation-on-start',
-    'dobetterweb/render-blocking-resources',
     'dobetterweb/no-document-write',
     'dobetterweb/no-mutation-events',
     'dobetterweb/no-vulnerable-libraries',
diff --git a/lighthouse-core/test/audits/dobetterweb/render-blocking-resources-test.js b/lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js
similarity index 58%
rename from lighthouse-core/test/audits/dobetterweb/render-blocking-resources-test.js
rename to lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js
index cc5796aff431..24371445e226 100644
--- a/lighthouse-core/test/audits/dobetterweb/render-blocking-resources-test.js
+++ b/lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js
@@ -5,8 +5,7 @@
  */
 'use strict';
 
-const RenderBlockingResourcesAudit =
-    require('../../../audits/dobetterweb/render-blocking-resources.js');
+const RenderBlockingResourcesAudit = require('../../../audits/byte-efficiency/render-blocking-resources.js');
 
 const mobile3G = require('../../../config/constants').throttling.mobile3G;
 const Runner = require('../../../runner');
@@ -22,16 +21,19 @@ const devtoolsLog = require('../../fixtures/traces/progressive-app-m60.devtools.
 
 describe('Render blocking resources audit', () => {
   it('evaluates http2 input correctly', async () => {
-    const artifacts = Object.assign({
-      traces: {defaultPass: trace},
-      devtoolsLogs: {defaultPass: devtoolsLog},
-      TagsBlockingFirstPaint: [
-        {
-          tag: {url: 'https://pwa.rocks/script.js'},
-          transferSize: 621,
-        },
-      ],
-    }, Runner.instantiateComputedArtifacts());
+    const artifacts = Object.assign(
+      {
+        traces: {defaultPass: trace},
+        devtoolsLogs: {defaultPass: devtoolsLog},
+        TagsBlockingFirstPaint: [
+          {
+            tag: {url: 'https://pwa.rocks/script.js'},
+            transferSize: 621,
+          },
+        ],
+      },
+      Runner.instantiateComputedArtifacts()
+    );
 
     const settings = {throttlingMethod: 'simulate', throttling: mobile3G};
     const result = await RenderBlockingResourcesAudit.audit(artifacts, {settings});
@@ -42,42 +44,55 @@ describe('Render blocking resources audit', () => {
   describe('#estimateSavingsFromInlining', () => {
     const estimate = RenderBlockingResourcesAudit.estimateSavingsFromInlining;
 
-    let requestId = 1;
-    const record = props => {
-      const ret = Object.assign({parsedURL: {}, requestId: requestId++}, props);
-      Object.defineProperty(ret, 'transferSize', {
-        get() {
-          return ret._transferSize;
-        },
-      });
-      return ret;
-    };
+    let requestId;
+    let record;
 
-    it('computes savings from inling', () => {
+    beforeEach(() => {
+      requestId = 1;
+      record = props => {
+        const ret = Object.assign({parsedURL: {}, requestId: requestId++}, props);
+        Object.defineProperty(ret, 'transferSize', {
+          get() {
+            return ret._transferSize;
+          },
+        });
+        return ret;
+      };
+    });
+
+    it('computes savings from deferring', () => {
       const serverResponseTimeByOrigin = new Map([['undefined://undefined', 100]]);
       const simulator = new Simulator({rtt: 1000, serverResponseTimeByOrigin});
       const documentNode = new NetworkNode(record({_transferSize: 4000}));
       const styleNode = new NetworkNode(record({_transferSize: 3000}));
       const scriptNode = new NetworkNode(record({_transferSize: 1000}));
-      const scriptExecution = new CPUNode({dur: 50 * 1000}, []);
+      const scriptExecution = new CPUNode({tid: 1, ts: 1, dur: 50 * 1000}, []);
+      const deferredIds = new Set([2, 3]);
+      const wastedBytesMap = new Map();
 
       documentNode.addDependent(scriptNode);
       documentNode.addDependent(styleNode);
-      scriptNode.addDependent(scriptExecution);
-      const result = estimate(simulator, documentNode);
+      documentNode.addDependent(scriptExecution);
+      const result = estimate(simulator, documentNode, deferredIds, wastedBytesMap);
       // Saving 1000 + 1000 + 100ms for TCP handshake + request/response + server response time
-      assert.equal(result, 2100);
+      // -200 ms for the CPU task that becomes new bottleneck
+      assert.equal(result, 1900);
     });
 
-    it('computes savings from inlining when new RT required', () => {
+    it('computes savings from inlining', () => {
       const serverResponseTimeByOrigin = new Map([['undefined://undefined', 100]]);
       const simulator = new Simulator({rtt: 1000, serverResponseTimeByOrigin});
-      const documentNode = new NetworkNode(record({_transferSize: 10000}));
-      const styleNode = new NetworkNode(record({_transferSize: 13000})); // pushes document over 14KB
+      const documentNode = new NetworkNode(record({_transferSize: 10 * 1000}));
+      const styleNode = new NetworkNode(
+        record({_transferSize: 23 * 1000, _resourceType: WebInspector.resourceTypes.Stylesheet})
+      ); // pushes document over 14KB
+      const deferredIds = new Set([2]);
+      const wastedBytesMap = new Map([[undefined, 18 * 1000]]);
       documentNode.addDependent(styleNode);
-      const result = estimate(simulator, documentNode);
-      // Saving 1000 + 100ms for TCP handshake + server response time, response RT still required
-      assert.equal(result, 1100);
+
+      const result = estimate(simulator, documentNode, deferredIds, wastedBytesMap);
+      // Saving 1000 + 1000 + 100ms for TCP handshake + 1 RT savings + server response time
+      assert.equal(result, 2100);
     });
   });
 });

From c2b340c2cfa8dd70949f401daa2bed214d00a2df Mon Sep 17 00:00:00 2001
From: Patrick Hulce <patrick.hulce@gmail.com>
Date: Fri, 20 Apr 2018 16:31:50 -0700
Subject: [PATCH 3/5] tests

---
 .../render-blocking-resources.js              |   2 +-
 .../render-blocking-resources-test.js         |   3 +-
 lighthouse-core/test/results/sample_v2.json   | 210 ++++++------------
 3 files changed, 68 insertions(+), 147 deletions(-)

diff --git a/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js b/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
index a129970b2cf0..a57ebef79df2 100644
--- a/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
+++ b/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
@@ -12,9 +12,9 @@
 
 const Audit = require('../audit');
 const Node = require('../../lib/dependency-graph/node');
-const CPUNode = require('../../lib/dependency-graph/cpu-node');
 const ByteEfficiencyAudit = require('./byte-efficiency-audit');
 const UnusedCSS = require('./unused-css-rules');
+const WebInspector = require('../../lib/web-inspector');
 
 // Because of the way we detect blocking stylesheets, asynchronously loaded
 // CSS with link[rel=preload] and an onload handler (see https://github.com/filamentgroup/loadCSS)
diff --git a/lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js b/lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js
index 24371445e226..99cd349bff95 100644
--- a/lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js
+++ b/lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js
@@ -5,13 +5,14 @@
  */
 'use strict';
 
-const RenderBlockingResourcesAudit = require('../../../audits/byte-efficiency/render-blocking-resources.js');
+const RenderBlockingResourcesAudit = require('../../../audits/byte-efficiency/render-blocking-resources.js'); // eslint-disable-line max-len
 
 const mobile3G = require('../../../config/constants').throttling.mobile3G;
 const Runner = require('../../../runner');
 const NetworkNode = require('../../../lib/dependency-graph/network-node');
 const CPUNode = require('../../../lib/dependency-graph/cpu-node');
 const Simulator = require('../../../lib/dependency-graph/simulator/simulator');
+const WebInspector = require('../../../lib/web-inspector');
 const assert = require('assert');
 
 const trace = require('../../fixtures/traces/progressive-app-m60.json');
diff --git a/lighthouse-core/test/results/sample_v2.json b/lighthouse-core/test/results/sample_v2.json
index 207d497290a4..e353b016af14 100644
--- a/lighthouse-core/test/results/sample_v2.json
+++ b/lighthouse-core/test/results/sample_v2.json
@@ -2910,6 +2910,69 @@
         }
       }
     },
+    "render-blocking-resources": {
+      "score": 0,
+      "displayValue": "5 resources delayed first paint by 1129ms",
+      "rawValue": 1129,
+      "scoreDisplayMode": "numeric",
+      "informative": true,
+      "name": "render-blocking-resources",
+      "description": "Eliminate render-blocking resources",
+      "helpText": "Resources are blocking the first paint of your page. Consider delivering critical JS/CSS inline and deferring all non-critical JS/styles. [Learn more](https://developers.google.com/web/tools/lighthouse/audits/blocking-resources).",
+      "details": {
+        "type": "table",
+        "headings": [
+          {
+            "key": "url",
+            "itemType": "url",
+            "text": "URL"
+          },
+          {
+            "key": "totalBytes",
+            "itemType": "bytes",
+            "displayUnit": "kb",
+            "granularity": 0.01,
+            "text": "Size (KB)"
+          },
+          {
+            "key": "wastedMs",
+            "itemType": "ms",
+            "text": "Download Time (ms)",
+            "granularity": 1
+          }
+        ],
+        "items": [
+          {
+            "url": "http://localhost:10200/dobetterweb/dbw_tester.css?delay=100",
+            "totalBytes": 821,
+            "wastedMs": 872.829
+          },
+          {
+            "url": "http://localhost:10200/dobetterweb/unknown404.css?delay=200",
+            "totalBytes": 139,
+            "wastedMs": 872.829
+          },
+          {
+            "url": "http://localhost:10200/dobetterweb/dbw_tester.css?delay=2200",
+            "totalBytes": 821,
+            "wastedMs": 872.829
+          },
+          {
+            "url": "http://localhost:10200/dobetterweb/dbw_partial_a.html?delay=200",
+            "totalBytes": 736,
+            "wastedMs": 722.829
+          },
+          {
+            "url": "http://localhost:10200/dobetterweb/dbw_tester.js",
+            "totalBytes": 1703,
+            "wastedMs": 722.8290000000002
+          }
+        ],
+        "summary": {
+          "wastedMs": 1129
+        }
+      }
+    },
     "unminified-css": {
       "score": 1,
       "displayValue": "",
@@ -3480,90 +3543,6 @@
         ]
       }
     },
-    "link-blocking-first-paint": {
-      "score": 0,
-      "displayValue": "4 resources delayed first paint by 2,214 ms",
-      "rawValue": 2214,
-      "extendedInfo": {
-        "value": {
-          "results": [
-            {
-              "url": "http://localhost:10200/dobetterweb/dbw_tester.css?delay=2200",
-              "totalBytes": 821,
-              "wastedMs": 2213.8710000144783
-            },
-            {
-              "url": "http://localhost:10200/dobetterweb/dbw_partial_a.html?delay=200",
-              "totalBytes": 736,
-              "wastedMs": 593.0220000154804
-            },
-            {
-              "url": "http://localhost:10200/dobetterweb/unknown404.css?delay=200",
-              "totalBytes": 139,
-              "wastedMs": 577.7950000192504
-            },
-            {
-              "url": "http://localhost:10200/dobetterweb/dbw_tester.css?delay=100",
-              "totalBytes": 821,
-              "wastedMs": 569.1630000073928
-            }
-          ]
-        }
-      },
-      "scoreDisplayMode": "numeric",
-      "informative": true,
-      "name": "link-blocking-first-paint",
-      "description": "Reduce render-blocking stylesheets",
-      "helpText": "External stylesheets are blocking the first paint of your page. Consider delivering critical CSS via `<style>` tags and deferring non-critical styles. [Learn more](https://developers.google.com/web/tools/lighthouse/audits/blocking-resources).",
-      "details": {
-        "type": "table",
-        "headings": [
-          {
-            "key": "url",
-            "itemType": "url",
-            "text": "URL"
-          },
-          {
-            "key": "totalBytes",
-            "itemType": "bytes",
-            "displayUnit": "kb",
-            "granularity": 0.01,
-            "text": "Size (KB)"
-          },
-          {
-            "key": "wastedMs",
-            "itemType": "ms",
-            "text": "Delayed Paint By (ms)",
-            "granularity": 1
-          }
-        ],
-        "items": [
-          {
-            "url": "http://localhost:10200/dobetterweb/dbw_tester.css?delay=2200",
-            "totalBytes": 821,
-            "wastedMs": 2213.8710000144783
-          },
-          {
-            "url": "http://localhost:10200/dobetterweb/dbw_partial_a.html?delay=200",
-            "totalBytes": 736,
-            "wastedMs": 593.0220000154804
-          },
-          {
-            "url": "http://localhost:10200/dobetterweb/unknown404.css?delay=200",
-            "totalBytes": 139,
-            "wastedMs": 577.7950000192504
-          },
-          {
-            "url": "http://localhost:10200/dobetterweb/dbw_tester.css?delay=100",
-            "totalBytes": 821,
-            "wastedMs": 569.1630000073928
-          }
-        ],
-        "summary": {
-          "wastedMs": 2214
-        }
-      }
-    },
     "no-document-write": {
       "score": 0,
       "displayValue": "",
@@ -4155,60 +4134,6 @@
         ]
       }
     },
-    "script-blocking-first-paint": {
-      "score": 0,
-      "displayValue": "1 resource delayed first paint by 1,148 ms",
-      "rawValue": 1148,
-      "extendedInfo": {
-        "value": {
-          "results": [
-            {
-              "url": "http://localhost:10200/dobetterweb/dbw_tester.js",
-              "totalBytes": 1703,
-              "wastedMs": 1148.00399998785
-            }
-          ]
-        }
-      },
-      "scoreDisplayMode": "numeric",
-      "informative": true,
-      "name": "script-blocking-first-paint",
-      "description": "Reduce render-blocking scripts",
-      "helpText": "Script elements are blocking the first paint of your page. Consider inlining critical scripts and deferring non-critical ones. [Learn more](https://developers.google.com/web/tools/lighthouse/audits/blocking-resources).",
-      "details": {
-        "type": "table",
-        "headings": [
-          {
-            "key": "url",
-            "itemType": "url",
-            "text": "URL"
-          },
-          {
-            "key": "totalBytes",
-            "itemType": "bytes",
-            "displayUnit": "kb",
-            "granularity": 0.01,
-            "text": "Size (KB)"
-          },
-          {
-            "key": "wastedMs",
-            "itemType": "ms",
-            "text": "Delayed Paint By (ms)",
-            "granularity": 1
-          }
-        ],
-        "items": [
-          {
-            "url": "http://localhost:10200/dobetterweb/dbw_tester.js",
-            "totalBytes": 1703,
-            "wastedMs": 1148.00399998785
-          }
-        ],
-        "summary": {
-          "wastedMs": 1148
-        }
-      }
-    },
     "uses-http2": {
       "score": 0,
       "displayValue": "15 requests were not handled over HTTP/2",
@@ -4766,12 +4691,7 @@
           "group": "perf-metric"
         },
         {
-          "id": "link-blocking-first-paint",
-          "weight": 0,
-          "group": "perf-hint"
-        },
-        {
-          "id": "script-blocking-first-paint",
+          "id": "render-blocking-resources",
           "weight": 0,
           "group": "perf-hint"
         },
@@ -5403,6 +5323,6 @@
     }
   },
   "timing": {
-    "total": 877
+    "total": 740
   }
 }
\ No newline at end of file

From f5d3b6543d50bc652d3e2dd828adabf32d89368b Mon Sep 17 00:00:00 2001
From: Patrick Hulce <patrick.hulce@gmail.com>
Date: Wed, 25 Apr 2018 11:24:09 -0700
Subject: [PATCH 4/5] feedback

---
 .../render-blocking-resources.js              | 40 ++++++++++++-------
 .../render-blocking-resources-test.js         |  4 +-
 2 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js b/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
index a57ebef79df2..903da47a709c 100644
--- a/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
+++ b/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
@@ -80,7 +80,8 @@ class RenderBlockingResources extends Audit {
       // i.e. the referenced font asset won't become inlined just because you inline the CSS
       node.traverse(node => deferredNodeIds.add(node.id));
 
-      const wastedMs = nodeTiming.endTime - nodeTiming.startTime;
+      // "wastedMs" is the download time of the network request, responseReceived - requestSent
+      const wastedMs = Math.round(nodeTiming.endTime - nodeTiming.startTime);
       if (wastedMs < MINIMUM_WASTED_MS) continue;
 
       results.push({
@@ -94,7 +95,7 @@ class RenderBlockingResources extends Audit {
       return {results, wastedMs: 0};
     }
 
-    const wastedMs = RenderBlockingResources.estimateSavingsFromInlining(
+    const wastedMs = RenderBlockingResources.estimateSavingsWithGraphs(
       simulator,
       fcpSimulation.optimisticGraph,
       deferredNodeIds,
@@ -105,33 +106,44 @@ class RenderBlockingResources extends Audit {
   }
 
   /**
+   * Estimates how much faster this page would reach FCP if we inlined all the used CSS from the
+   * render blocking stylesheets and deferred all the scripts. This is more conservative than
+   * removing all the assets and more aggressive than inlining everything.
+   *
+   * *Most* of the time, scripts in the head are there accidentally/due to lack of awareness
+   * rather than necessity, so we're comfortable with this balance. In the worst case, we're telling
+   * devs that they should be able to get to a reasonable first paint without JS, which is not a bad
+   * thing.
+   *
    * @param {Simulator} simulator
    * @param {Node} fcpGraph
    * @param {Set<string>} deferredIds
    * @param {Map<string, number>} wastedBytesMap
    * @return {number}
    */
-  static estimateSavingsFromInlining(simulator, fcpGraph, deferredIds, wastedBytesMap) {
+  static estimateSavingsWithGraphs(simulator, fcpGraph, deferredIds, wastedBytesMap) {
     const originalEstimate = simulator.simulate(fcpGraph).timeInMs;
 
     let totalChildNetworkBytes = 0;
-    const graphWithoutChildren = fcpGraph.cloneWithRelationships(node => {
-      const willDefer = deferredIds.has(node.id);
-      if (willDefer && node.type === Node.TYPES.NETWORK &&
-          node.record._resourceType === WebInspector.resourceTypes.Stylesheet) {
+    const minimalFCPGraph = fcpGraph.cloneWithRelationships(node => {
+      const canDeferRequest = deferredIds.has(node.id);
+      const isStylesheet = node.type === Node.TYPES.NETWORK &&
+          node.record._resourceType === WebInspector.resourceTypes.Stylesheet;
+      if (canDeferRequest && isStylesheet) {
+        // We'll inline the used bytes of the stylesheet and assume the rest can be deferred
         const wastedBytes = wastedBytesMap.get(node.record.url) || 0;
         totalChildNetworkBytes += node.record._transferSize - wastedBytes;
       }
 
-      // Include all nodes that couldn't be deferred
-      return !willDefer;
+      // If a node can be deferred, exclude it from the new FCP graph
+      return !canDeferRequest;
     });
 
-    graphWithoutChildren.record._transferSize += totalChildNetworkBytes;
-    const estimateAfterInlineA = simulator.simulate(graphWithoutChildren);
-    const estimateAfterInline = estimateAfterInlineA.timeInMs;
-    graphWithoutChildren.record._transferSize -= totalChildNetworkBytes;
-    return Math.max(originalEstimate - estimateAfterInline, 0);
+    // Add the inlined bytes to the HTML response
+    minimalFCPGraph.record._transferSize += totalChildNetworkBytes;
+    const estimateAfterInline = simulator.simulate(minimalFCPGraph).timeInMs;
+    minimalFCPGraph.record._transferSize -= totalChildNetworkBytes;
+    return Math.round(Math.max(originalEstimate - estimateAfterInline, 0));
   }
 
   /**
diff --git a/lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js b/lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js
index 99cd349bff95..29f3068036d1 100644
--- a/lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js
+++ b/lighthouse-core/test/audits/byte-efficiency/render-blocking-resources-test.js
@@ -42,8 +42,8 @@ describe('Render blocking resources audit', () => {
     assert.equal(result.rawValue, 0);
   });
 
-  describe('#estimateSavingsFromInlining', () => {
-    const estimate = RenderBlockingResourcesAudit.estimateSavingsFromInlining;
+  describe('#estimateSavingsWithGraphs', () => {
+    const estimate = RenderBlockingResourcesAudit.estimateSavingsWithGraphs;
 
     let requestId;
     let record;

From 2e88795c4019606dd6d3d066a07bd9c02fcde0df Mon Sep 17 00:00:00 2001
From: Patrick Hulce <patrick.hulce@gmail.com>
Date: Wed, 25 Apr 2018 12:29:17 -0700
Subject: [PATCH 5/5] helper functions ftw

---
 .../render-blocking-resources.js              | 47 ++++++++++++-------
 1 file changed, 30 insertions(+), 17 deletions(-)

diff --git a/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js b/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
index 903da47a709c..fae4a1cbc9ef 100644
--- a/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
+++ b/lighthouse-core/audits/byte-efficiency/render-blocking-resources.js
@@ -22,10 +22,18 @@ const WebInspector = require('../../lib/web-inspector');
 // to possibly be non-blocking (and they have minimal impact anyway).
 const MINIMUM_WASTED_MS = 50;
 
-const keyByUrl = arr => arr.reduce((map, node) => {
-  map[node.record && node.record.url] = node;
-  return map;
-}, {});
+/**
+ * Given a simulation's nodeTiming, return an object with the nodes/timing keyed by network URL
+ * @param {LH.Gatherer.Simulation.Result['nodeTiming']} nodeTimingMap
+ * @return {Object<string, {node: Node, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>}
+ */
+const getNodesAndTimingByUrl = nodeTimingMap => {
+  const nodes = Array.from(nodeTimingMap.keys());
+  return nodes.reduce((map, node) => {
+    map[node.record && node.record.url] = {node, nodeTiming: nodeTimingMap.get(node)};
+    return map;
+  }, {});
+};
 
 class RenderBlockingResources extends Audit {
   /**
@@ -37,9 +45,10 @@ class RenderBlockingResources extends Audit {
       description: 'Eliminate render-blocking resources',
       informative: true,
       scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
-      helpText: 'Resources are blocking the first paint of your page. Consider ' +
-          'delivering critical JS/CSS inline and deferring all non-critical ' +
-          'JS/styles. [Learn more](https://developers.google.com/web/tools/lighthouse/audits/blocking-resources).',
+      helpText:
+        'Resources are blocking the first paint of your page. Consider ' +
+        'delivering critical JS/CSS inline and deferring all non-critical ' +
+        'JS/styles. [Learn more](https://developers.google.com/web/tools/lighthouse/audits/blocking-resources).',
       requiredArtifacts: ['CSSUsage', 'URL', 'TagsBlockingFirstPaint', 'traces'],
     };
   }
@@ -61,19 +70,17 @@ class RenderBlockingResources extends Audit {
     const fcpSimulation = await artifacts.requestFirstContentfulPaint(metricComputationData);
     const fcpTsInMs = traceOfTab.timestamps.firstContentfulPaint / 1000;
 
-    const nodeTimingMap = fcpSimulation.optimisticEstimate.nodeTiming;
-    const nodesByUrl = keyByUrl(Array.from(nodeTimingMap.keys()));
+    const nodesByUrl = getNodesAndTimingByUrl(fcpSimulation.optimisticEstimate.nodeTiming);
 
     const results = [];
     const deferredNodeIds = new Set();
     for (const resource of artifacts.TagsBlockingFirstPaint) {
       // Ignore any resources that finished after observed FCP (they're clearly not render-blocking)
       if (resource.endTime * 1000 > fcpTsInMs) continue;
-
-      const node = nodesByUrl[resource.tag.url];
-      const nodeTiming = nodeTimingMap.get(node);
       // TODO(phulce): beacon these occurences to Sentry to improve FCP graph
-      if (!node) continue;
+      if (!nodesByUrl[resource.tag.url]) continue;
+
+      const {node, nodeTiming} = nodesByUrl[resource.tag.url];
 
       // Mark this node and all it's dependents as deferrable
       // TODO(phulce): make this slightly more surgical
@@ -127,8 +134,9 @@ class RenderBlockingResources extends Audit {
     let totalChildNetworkBytes = 0;
     const minimalFCPGraph = fcpGraph.cloneWithRelationships(node => {
       const canDeferRequest = deferredIds.has(node.id);
-      const isStylesheet = node.type === Node.TYPES.NETWORK &&
-          node.record._resourceType === WebInspector.resourceTypes.Stylesheet;
+      const isStylesheet =
+        node.type === Node.TYPES.NETWORK &&
+        node.record._resourceType === WebInspector.resourceTypes.Stylesheet;
       if (canDeferRequest && isStylesheet) {
         // We'll inline the used bytes of the stylesheet and assume the rest can be deferred
         const wastedBytes = wastedBytesMap.get(node.record.url) || 0;
@@ -180,8 +188,13 @@ class RenderBlockingResources extends Audit {
 
     const headings = [
       {key: 'url', itemType: 'url', text: 'URL'},
-      {key: 'totalBytes', itemType: 'bytes', displayUnit: 'kb', granularity: 0.01,
-        text: 'Size (KB)'},
+      {
+        key: 'totalBytes',
+        itemType: 'bytes',
+        displayUnit: 'kb',
+        granularity: 0.01,
+        text: 'Size (KB)',
+      },
       {key: 'wastedMs', itemType: 'ms', text: 'Download Time (ms)', granularity: 1},
     ];