static computeWasteWithGraph(results, graph, simulator, options) {
    options = Object.assign({label: ''}, options);
    const beforeLabel = `${this.meta.id}-${options.label}-before`;
    const afterLabel = `${this.meta.id}-${options.label}-after`;

    const urlsToChange = new Set(results.map(result => result.url));
    const simulationBefore = simulator.simulate(graph, {label: beforeLabel});

    // Update all the protocols to reflect implementing our recommendations
    /** @type {Map<string, string>} */
    const originalProtocols = new Map();
    graph.traverse(node => {
      if (node.type !== 'network') return;
      if (!urlsToChange.has(node.request.url)) return;

      originalProtocols.set(node.request.requestId, node.request.protocol);
      node.request.protocol = 'h2';
    });

    const simulationAfter = simulator.simulate(graph, {label: afterLabel});

    // Restore the original protocol after we've done our simulation
    graph.traverse(node => {
      if (node.type !== 'network') return;
      const originalProtocol = originalProtocols.get(node.request.requestId);
      if (originalProtocol === undefined) return;
      node.request.protocol = originalProtocol;
    });

    const savings = simulationBefore.timeInMs - simulationAfter.timeInMs;

    return {
      // Round waste to nearest 10ms
      savings: Math.round(Math.max(savings, 0) / 10) * 10,
      simulationBefore,
      simulationAfter,
    };
  }
Computes the estimated effect of all results being converted to http/2 on the provided graph.

@param {Array<{url: string}>} results
@param {LH.Gatherer.Simulation.GraphNode} graph
@param {LH.Gatherer.Simulation.Simulator} simulator
@param {{label?: string}=} options
@return {{savings: number, simulationBefore: LH.Gatherer.Simulation.Result, simulationAfter: LH.Gatherer.Simulation.Result}}