static determineNonHttp2Resources(networkRecords, classifiedEntities) {
    /** @type {Array<{url: string, protocol: string}>} */
    const nonHttp2Resources = [];

    /** @type {Set<string>} */
    const seenURLs = new Set();
    /** @type {Map<string, Array<LH.Artifacts.NetworkRequest>>} */
    const groupedByOrigin = new Map();
    for (const record of networkRecords) {
      if (!UsesHTTP2Audit.isMultiplexableStaticAsset(record, classifiedEntities)) continue;
      if (UrlUtils.isLikeLocalhost(record.parsedURL.host)) continue;
      const existing = groupedByOrigin.get(record.parsedURL.securityOrigin) || [];
      existing.push(record);
      groupedByOrigin.set(record.parsedURL.securityOrigin, existing);
    }

    for (const record of networkRecords) {
      // Skip duplicates.
      if (seenURLs.has(record.url)) continue;
      // Check if record is not served through the service worker, servicer worker uses http/1.1 as a protocol.
      // These can generate false positives (bug: https://github.com/GoogleChrome/lighthouse/issues/7158).
      if (record.fetchedViaServiceWorker) continue;
      // Test the protocol to see if it was http/1.1.
      const isOldHttp = /HTTP\/[01][.\d]?/i.test(record.protocol);
      if (!isOldHttp) continue;
      // Check if the origin has enough requests to bother flagging.
      const group = groupedByOrigin.get(record.parsedURL.securityOrigin) || [];
      if (group.length < 6) continue;

      seenURLs.add(record.url);
      nonHttp2Resources.push({protocol: record.protocol, url: record.url});
    }

    return nonHttp2Resources;
  }
Determine the set of resources that aren't HTTP/2 but should be.
We're a little conservative about what we surface for a few reasons:

   - The simulator approximation of HTTP/2 is a little more generous than reality.
   - There's a bit of debate surrounding HTTP/2 due to its worse performance in environments with high packet loss.**
   - It's something that you'd have absolutely zero control over with a third-party (can't defer to fix it for example).

Therefore, we only surface requests that were...

   - Served over HTTP/1.1 or earlier
   - Served over an origin that serves at least 6 static asset requests
     (if there aren't more requests than browser's max/host, multiplexing isn't as big a deal)
   - Not served on localhost (h2 is a pain to deal with locally & and CI)

** = https://news.ycombinator.com/item?id=19086639
     https://www.twilio.com/blog/2017/10/http2-issues.html
     https://www.cachefly.com/http-2-is-not-a-magic-bullet/

@param {Array<LH.Artifacts.NetworkRequest>} networkRecords
@param {LH.Artifacts.EntityClassification} classifiedEntities
@return {Array<{url: string, protocol: string}>}