sandwich_prefetch.py

# Copyright 2016 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""
Implements a task builder for benchmarking effects of NoState Prefetch.
Noticeable steps of the task pipeline:
  * Save a WPR archive
  * Process the WPR archive to make all resources cacheable
  * Process cache archive to patch response headers back to their original
      values.
  * Find out which resources are discoverable by NoState Prefetch
      (HTMLPreloadScanner)
  * Load pages with empty/full/prefetched cache
  * Extract most important metrics to a CSV
"""

import csv
import logging
import json
import os
import re
import shutil
import urlparse

import chrome_cache
import common_util
import loading_trace
from prefetch_view import PrefetchSimulationView
from request_dependencies_lens import RequestDependencyLens
import sandwich_metrics
import sandwich_runner
import sandwich_utils
import task_manager
import wpr_backend


class Discoverer(object):
  # Do not prefetch anything.
  EmptyCache = 'empty-cache'

  # Prefetches everything to load fully from cache (impossible in practice).
  FullCache = 'full-cache'

  # Prefetches the first resource following the redirection chain.
  MainDocument = 'main-document'

  # All resources which are fetched from the main document and their
  # redirections.
  Parser = 'parser'

  # Simulation of HTMLPreloadScanner on the main document and their
  # redirections and subsets:
  #   Store: only resources that don't have Cache-Control: No-Store.
  HTMLPreloadScanner = 'html-scanner'
  HTMLPreloadScannerStore = 'html-scanner-store'


# List of all available sub-resource discoverers.
SUBRESOURCE_DISCOVERERS = set([
  Discoverer.EmptyCache,
  Discoverer.FullCache,
  Discoverer.MainDocument,
  Discoverer.Parser,
  Discoverer.HTMLPreloadScanner,
  Discoverer.HTMLPreloadScannerStore,
])


_UPLOAD_DATA_STREAM_REQUESTS_REGEX = re.compile(r'^\d+/(?P<url>.*)$')


def _NormalizeUrl(url):
  """Returns normalized URL such as removing trailing slashes."""
  parsed_url = list(urlparse.urlparse(url))
  parsed_url[2] = re.sub(r'/{2,}', r'/', parsed_url[2])
  return urlparse.urlunparse(parsed_url)


def _PatchCacheArchive(cache_archive_path, loading_trace_path,
                       cache_archive_dest_path):
  """Patch the cache archive.

  Note: This method update the raw response headers of cache entries' to store
    the ones such as Set-Cookie that were pruned by the
    net::HttpCacheTransaction, and remove the stream index 2 holding resource's
    compile meta data.

  Args:
    cache_archive_path: Input archive's path to patch.
    loading_trace_path: Path of the loading trace that have recorded the cache
        archive <cache_archive_path>.
    cache_archive_dest_path: Archive destination's path.
  """
  trace = loading_trace.LoadingTrace.FromJsonFile(loading_trace_path)
  with common_util.TemporaryDirectory(prefix='sandwich_tmp') as tmp_path:
    cache_path = os.path.join(tmp_path, 'cache')
    chrome_cache.UnzipDirectoryContent(cache_archive_path, cache_path)
    cache_backend = chrome_cache.CacheBackend(cache_path, 'simple')
    cache_entries = set(cache_backend.ListKeys())
    logging.info('Original cache size: %d bytes' % cache_backend.GetSize())
    for request in sandwich_utils.FilterOutDataAndIncompleteRequests(
        trace.request_track.GetEvents()):
      # On requests having an upload data stream such as POST requests,
      # net::HttpCache::GenerateCacheKey() prefixes the cache entry's key with
      # the upload data stream's session unique identifier.
      #
      # It is fine to not patch these requests since when reopening Chrome,
      # there is no way the entry can be reused since the upload data stream's
      # identifier will be different.
      #
      # The fact that these entries are kept in the cache after closing Chrome
      # properly by closing the Chrome tab as the ChromeControler.SetSlowDeath()
      # do is known chrome bug (crbug.com/610725).
      if request.url not in cache_entries:
        continue
      # Chrome prunes Set-Cookie from response headers before storing them in
      # disk cache. Also, it adds implicit "Vary: cookie" header to all redirect
      # response headers. Sandwich manages the cache, but between recording the
      # cache and benchmarking the cookie jar is invalidated. This leads to
      # invalidation of all cacheable redirects.
      raw_headers = request.GetRawResponseHeaders()
      cache_backend.UpdateRawResponseHeaders(request.url, raw_headers)
      # NoState-Prefetch would only fetch the resources, but not parse them.
      cache_backend.DeleteStreamForKey(request.url, 2)
    chrome_cache.ZipDirectoryContent(cache_path, cache_archive_dest_path)
    logging.info('Patched cache size: %d bytes' % cache_backend.GetSize())


def _DiscoverRequests(dependencies_lens, subresource_discoverer):
  trace = dependencies_lens.loading_trace
  first_resource_request = trace.request_track.GetFirstResourceRequest()

  if subresource_discoverer == Discoverer.EmptyCache:
    requests = []
  elif subresource_discoverer == Discoverer.FullCache:
    requests = dependencies_lens.loading_trace.request_track.GetEvents()
  elif subresource_discoverer == Discoverer.MainDocument:
    requests = [dependencies_lens.GetRedirectChain(first_resource_request)[-1]]
  elif subresource_discoverer == Discoverer.Parser:
    requests = PrefetchSimulationView.ParserDiscoverableRequests(
        first_resource_request, dependencies_lens)
  elif subresource_discoverer == Discoverer.HTMLPreloadScanner:
    requests = PrefetchSimulationView.PreloadedRequests(
        first_resource_request, dependencies_lens, trace)
  else:
    assert False
  logging.info('number of requests discovered by %s: %d',
      subresource_discoverer, len(requests))
  return requests


def _PruneOutOriginalNoStoreRequests(original_headers_path, requests):
  with open(original_headers_path) as file_input:
    original_headers = json.load(file_input)
  pruned_requests = set()
  for request in requests:
    url = _NormalizeUrl(request.url)
    if url not in original_headers:
      # TODO(gabadie): Investigate why these requests were not in WPR.
      assert request.failed
      logging.warning(
          'could not find original headers for: %s (failure: %s)',
          url, request.error_text)
      continue
    request_original_headers = original_headers[url]
    if ('cache-control' in request_original_headers and
        'no-store' in request_original_headers['cache-control'].lower()):
      pruned_requests.add(request)
  return [r for r in requests if r not in pruned_requests]


def _ExtractDiscoverableUrls(
    original_headers_path, loading_trace_path, subresource_discoverer):
  """Extracts discoverable resource urls from a loading trace according to a
  sub-resource discoverer.

  Args:
    original_headers_path: Path of JSON containing the original headers.
    loading_trace_path: Path of the loading trace recorded at original cache
      creation.
    subresource_discoverer: The sub-resources discoverer that should white-list
      the resources to keep in cache for the NoState-Prefetch benchmarks.

  Returns:
    A set of urls.
  """
  assert subresource_discoverer in SUBRESOURCE_DISCOVERERS, \
      'unknown prefetch simulation {}'.format(subresource_discoverer)
  logging.info('loading %s', loading_trace_path)
  trace = loading_trace.LoadingTrace.FromJsonFile(loading_trace_path)
  dependencies_lens = RequestDependencyLens(trace)

  # Build the list of discovered requests according to the desired simulation.
  discovered_requests = []
  if subresource_discoverer == Discoverer.HTMLPreloadScannerStore:
    requests = _DiscoverRequests(
        dependencies_lens, Discoverer.HTMLPreloadScanner)
    discovered_requests = _PruneOutOriginalNoStoreRequests(
        original_headers_path, requests)
  else:
    discovered_requests = _DiscoverRequests(
        dependencies_lens, subresource_discoverer)

  whitelisted_urls = set()
  for request in sandwich_utils.FilterOutDataAndIncompleteRequests(
      discovered_requests):
    logging.debug('white-listing %s', request.url)
    whitelisted_urls.add(request.url)
  logging.info('number of white-listed resources: %d', len(whitelisted_urls))
  return whitelisted_urls


def _PrintUrlSetComparison(ref_url_set, url_set, url_set_name):
  """Compare URL sets and log the diffs.

  Args:
    ref_url_set: Set of reference urls.
    url_set: Set of urls to compare to the reference.
    url_set_name: The set name for logging purposes.
  """
  assert type(ref_url_set) == set
  assert type(url_set) == set
  if ref_url_set == url_set:
    logging.info('  %d %s are matching.' % (len(ref_url_set), url_set_name))
    return
  missing_urls = ref_url_set.difference(url_set)
  unexpected_urls = url_set.difference(ref_url_set)
  logging.error('  %s are not matching (expected %d, had %d)' % \
      (url_set_name, len(ref_url_set), len(url_set)))
  logging.error('    List of %d missing resources:' % len(missing_urls))
  for url in sorted(missing_urls):
    logging.error('-     ' + url)
  logging.error('    List of %d unexpected resources:' % len(unexpected_urls))
  for url in sorted(unexpected_urls):
    logging.error('+     ' + url)


class _RunOutputVerifier(object):
  """Object to verify benchmark run from traces and WPR log stored in the
  runner output directory.
  """

  def __init__(self, cache_validation_result, benchmark_setup):
    """Constructor.

    Args:
      cache_validation_result: JSON of the cache validation task.
      benchmark_setup: JSON of the benchmark setup.
    """
    self._cache_whitelist = set(benchmark_setup['cache_whitelist'])
    self._original_requests = set(
        cache_validation_result['effective_encoded_data_lengths'].keys())
    self._original_post_requests = set(
        cache_validation_result['effective_post_requests'])
    self._original_cached_requests = self._original_requests.intersection(
        self._cache_whitelist)
    self._original_uncached_requests = self._original_requests.difference(
        self._cache_whitelist)
    self._all_sent_url_requests = set()

  def VerifyTrace(self, trace):
    """Verifies a trace with the cache validation result and the benchmark
    setup.
    """
    effective_requests = sandwich_utils.ListUrlRequests(
        trace, sandwich_utils.RequestOutcome.All)
    effective_post_requests = sandwich_utils.ListUrlRequests(
        trace, sandwich_utils.RequestOutcome.Post)
    effective_cached_requests = sandwich_utils.ListUrlRequests(
        trace, sandwich_utils.RequestOutcome.ServedFromCache)
    effective_uncached_requests = sandwich_utils.ListUrlRequests(
        trace, sandwich_utils.RequestOutcome.NotServedFromCache)

    missing_requests = self._original_requests.difference(effective_requests)
    unexpected_requests = effective_requests.difference(self._original_requests)
    expected_cached_requests = \
        self._original_cached_requests.difference(missing_requests)
    expected_uncached_requests = self._original_uncached_requests.union(
        unexpected_requests).difference(missing_requests)

    # POST requests are known to be unable to use the cache.
    expected_cached_requests.difference_update(effective_post_requests)
    expected_uncached_requests.update(effective_post_requests)

    _PrintUrlSetComparison(self._original_requests, effective_requests,
                           'All resources')
    _PrintUrlSetComparison(set(), effective_post_requests, 'POST resources')
    _PrintUrlSetComparison(expected_cached_requests, effective_cached_requests,
                           'Cached resources')
    _PrintUrlSetComparison(expected_uncached_requests,
                           effective_uncached_requests, 'Non cached resources')

    self._all_sent_url_requests.update(effective_uncached_requests)

  def VerifyWprLog(self, wpr_log_path):
    """Verifies WPR log with previously verified traces."""
    all_wpr_requests = wpr_backend.ExtractRequestsFromLog(wpr_log_path)
    all_wpr_urls = set()
    unserved_wpr_urls = set()
    wpr_command_colliding_urls = set()

    for request in all_wpr_requests:
      if request.is_wpr_host:
        continue
      if urlparse.urlparse(request.url).path.startswith('/web-page-replay'):
        wpr_command_colliding_urls.add(request.url)
      elif request.is_served is False:
        unserved_wpr_urls.add(request.url)
      all_wpr_urls.add(request.url)

    _PrintUrlSetComparison(set(), unserved_wpr_urls,
                           'Distinct unserved resources from WPR')
    _PrintUrlSetComparison(set(), wpr_command_colliding_urls,
                           'Distinct resources colliding to WPR commands')
    _PrintUrlSetComparison(all_wpr_urls, self._all_sent_url_requests,
                           'Distinct resource requests to WPR')


def _ValidateCacheArchiveContent(cache_build_trace_path, cache_archive_path):
  """Validates a cache archive content.

  Args:
    cache_build_trace_path: Path of the generated trace at the cache build time.
    cache_archive_path: Cache archive's path to validate.

  Returns:
    {
      'effective_encoded_data_lengths':
        {URL of all requests: encoded_data_length},
      'effective_post_requests': [URLs of POST requests],
      'expected_cached_resources': [URLs of resources expected to be cached],
      'successfully_cached': [URLs of cached sub-resources]
    }
  """
  # TODO(gabadie): What's the best way of propagating errors happening in here?
  logging.info('lists cached urls from %s' % cache_archive_path)
  with common_util.TemporaryDirectory() as cache_directory:
    chrome_cache.UnzipDirectoryContent(cache_archive_path, cache_directory)
    cache_keys = set(
        chrome_cache.CacheBackend(cache_directory, 'simple').ListKeys())
  trace = loading_trace.LoadingTrace.FromJsonFile(cache_build_trace_path)
  effective_requests = sandwich_utils.ListUrlRequests(
      trace, sandwich_utils.RequestOutcome.All)
  effective_post_requests = sandwich_utils.ListUrlRequests(
      trace, sandwich_utils.RequestOutcome.Post)
  effective_encoded_data_lengths = {}
  for request in sandwich_utils.FilterOutDataAndIncompleteRequests(
      trace.request_track.GetEvents()):
    if request.from_disk_cache or request.served_from_cache:
      # At cache archive creation time, a request might be loaded several times,
      # but avoid the request.encoded_data_length == 0 if loaded from cache.
      continue
    if request.url in effective_encoded_data_lengths:
      effective_encoded_data_lengths[request.url] = max(
          effective_encoded_data_lengths[request.url],
          request.GetResponseTransportLength())
    else:
      effective_encoded_data_lengths[request.url] = (
          request.GetResponseTransportLength())

  upload_data_stream_cache_entry_keys = set()
  upload_data_stream_requests = set()
  for cache_entry_key in cache_keys:
    match = _UPLOAD_DATA_STREAM_REQUESTS_REGEX.match(cache_entry_key)
    if not match:
      continue
    upload_data_stream_cache_entry_keys.add(cache_entry_key)
    upload_data_stream_requests.add(match.group('url'))

  expected_cached_requests = effective_requests.difference(
      effective_post_requests)
  effective_cache_keys = cache_keys.difference(
      upload_data_stream_cache_entry_keys)

  _PrintUrlSetComparison(effective_post_requests, upload_data_stream_requests,
                         'POST resources')
  _PrintUrlSetComparison(expected_cached_requests, effective_cache_keys,
                         'Cached resources')

  return {
      'effective_encoded_data_lengths': effective_encoded_data_lengths,
      'effective_post_requests': [url for url in effective_post_requests],
      'expected_cached_resources': [url for url in expected_cached_requests],
      'successfully_cached_resources': [url for url in effective_cache_keys]
  }


def _ProcessRunOutputDir(
    cache_validation_result, benchmark_setup, runner_output_dir):
  """Process benchmark's run output directory.

  Args:
    cache_validation_result: Same as for _RunOutputVerifier
    benchmark_setup: Same as for _RunOutputVerifier
    runner_output_dir: Same as for SandwichRunner.output_dir

  Returns:
    List of dictionary.
  """
  run_metrics_list = []
  run_output_verifier = _RunOutputVerifier(
      cache_validation_result, benchmark_setup)
  cached_encoded_data_lengths = (
      cache_validation_result['effective_encoded_data_lengths'])
  for repeat_id, repeat_dir in sandwich_runner.WalkRepeatedRuns(
      runner_output_dir):
    trace_path = os.path.join(repeat_dir, sandwich_runner.TRACE_FILENAME)

    logging.info('loading trace: %s', trace_path)
    trace = loading_trace.LoadingTrace.FromJsonFile(trace_path)

    logging.info('verifying trace: %s', trace_path)
    run_output_verifier.VerifyTrace(trace)

    logging.info('extracting metrics from trace: %s', trace_path)

    # Gather response size per URLs.
    response_sizes = {}
    for request in sandwich_utils.FilterOutDataAndIncompleteRequests(
        trace.request_track.GetEvents()):
      # Ignore requests served from the blink's cache.
      if request.served_from_cache:
        continue
      if request.from_disk_cache:
        if request.url in cached_encoded_data_lengths:
          response_size = cached_encoded_data_lengths[request.url]
        else:
          # Some fat webpages may overflow the Memory cache, and so some
          # requests might be served from disk cache couple of times per page
          # load.
          logging.warning('Looks like could be served from memory cache: %s',
              request.url)
          if request.url in response_sizes:
            response_size = response_sizes[request.url]
      else:
        response_size = request.GetResponseTransportLength()
      response_sizes[request.url] = response_size

    # Sums the served from cache/network bytes.
    served_from_network_bytes = 0
    served_from_cache_bytes = 0
    urls_hitting_network = set()
    for request in sandwich_utils.FilterOutDataAndIncompleteRequests(
        trace.request_track.GetEvents()):
      # Ignore requests served from the blink's cache.
      if request.served_from_cache:
        continue
      urls_hitting_network.add(request.url)
      if request.from_disk_cache:
        served_from_cache_bytes += response_sizes[request.url]
      else:
        served_from_network_bytes += response_sizes[request.url]

    # Make sure the served from blink's cache requests have at least one
    # corresponding request that was not served from the blink's cache.
    for request in sandwich_utils.FilterOutDataAndIncompleteRequests(
        trace.request_track.GetEvents()):
      assert (request.url in urls_hitting_network or
              not request.served_from_cache)

    run_metrics = {
        'url': trace.url,
        'repeat_id': repeat_id,
        'subresource_discoverer': benchmark_setup['subresource_discoverer'],
        'cache_recording.subresource_count':
            len(cache_validation_result['effective_encoded_data_lengths']),
        'cache_recording.cached_subresource_count_theoretic':
            len(cache_validation_result['successfully_cached_resources']),
        'cache_recording.cached_subresource_count':
            len(cache_validation_result['expected_cached_resources']),
        'benchmark.subresource_count': len(sandwich_utils.ListUrlRequests(
            trace, sandwich_utils.RequestOutcome.All)),
        'benchmark.served_from_cache_count_theoretic':
            len(benchmark_setup['cache_whitelist']),
        'benchmark.served_from_cache_count': len(sandwich_utils.ListUrlRequests(
            trace, sandwich_utils.RequestOutcome.ServedFromCache)),
        'benchmark.served_from_network_bytes': served_from_network_bytes,
        'benchmark.served_from_cache_bytes': served_from_cache_bytes
    }
    run_metrics.update(
        sandwich_metrics.ExtractCommonMetricsFromRepeatDirectory(
            repeat_dir, trace))
    run_metrics_list.append(run_metrics)
  run_metrics_list.sort(key=lambda e: e['repeat_id'])

  wpr_log_path = os.path.join(
      runner_output_dir, sandwich_runner.WPR_LOG_FILENAME)
  logging.info('verifying wpr log: %s', wpr_log_path)
  run_output_verifier.VerifyWprLog(wpr_log_path)
  return run_metrics_list


class PrefetchBenchmarkBuilder(task_manager.Builder):
  """A builder for a graph of tasks for NoState-Prefetch emulated benchmarks."""

  def __init__(self, common_builder):
    task_manager.Builder.__init__(self,
                                  common_builder.output_directory,
                                  common_builder.output_subdirectory)
    self._common_builder = common_builder

    self._original_headers_path = None
    self._wpr_archive_path = None
    self._cache_path = None
    self._trace_from_grabbing_reference_cache = None
    self._cache_validation_task = None
    self._PopulateCommonPipelines()

  def _PopulateCommonPipelines(self):
    """Creates necessary tasks to produce initial cache archive.

    Also creates a task for producing a json file with a mapping of URLs to
    subresources (urls-resources.json).

    Here is the full dependency tree for the returned task:
    common/patched-cache-validation.json
      depends on: common/patched-cache.zip
        depends on: common/original-cache.zip
          depends on: common/webpages-patched.wpr
            depends on: common/webpages.wpr
    """
    self._original_headers_path = self.RebaseOutputPath(
        'common/response-headers.json')

    @self.RegisterTask('common/webpages-patched.wpr',
                       dependencies=[self._common_builder.original_wpr_task])
    def BuildPatchedWpr():
      shutil.copyfile(
          self._common_builder.original_wpr_task.path, BuildPatchedWpr.path)
      wpr_archive = wpr_backend.WprArchiveBackend(BuildPatchedWpr.path)

      # Save up original response headers.
      original_response_headers = {e.url: e.GetResponseHeadersDict() \
          for e in wpr_archive.ListUrlEntries()}
      logging.info('save up response headers for %d resources',
                   len(original_response_headers))
      if not original_response_headers:
        # TODO(gabadie): How is it possible to not even have the main resource
        # in the WPR archive? Example URL can be found in:
        # http://crbug.com/623966#c5
        raise Exception(
            'Looks like no resources were recorded in WPR during: {}'.format(
                self._common_builder.original_wpr_task.name))
      with open(self._original_headers_path, 'w') as file_output:
        json.dump(original_response_headers, file_output)

      # Patch WPR.
      wpr_url_entries = wpr_archive.ListUrlEntries()
      for wpr_url_entry in wpr_url_entries:
        sandwich_utils.PatchWprEntryToBeCached(wpr_url_entry)
      logging.info('number of patched entries: %d', len(wpr_url_entries))
      wpr_archive.Persist()

    @self.RegisterTask('common/original-cache.zip', [BuildPatchedWpr])
    def BuildOriginalCache():
      runner = self._common_builder.CreateSandwichRunner()
      runner.wpr_archive_path = BuildPatchedWpr.path
      runner.cache_archive_path = BuildOriginalCache.path
      runner.cache_operation = sandwich_runner.CacheOperation.SAVE
      runner.output_dir = BuildOriginalCache.run_path
      runner.Run()
    BuildOriginalCache.run_path = BuildOriginalCache.path[:-4] + '-run'
    original_cache_trace_path = os.path.join(
        BuildOriginalCache.run_path, '0', sandwich_runner.TRACE_FILENAME)

    @self.RegisterTask('common/patched-cache.zip', [BuildOriginalCache])
    def BuildPatchedCache():
      _PatchCacheArchive(BuildOriginalCache.path,
          original_cache_trace_path, BuildPatchedCache.path)

    @self.RegisterTask('common/patched-cache-validation.json',
                       [BuildPatchedCache])
    def ValidatePatchedCache():
      cache_validation_result = _ValidateCacheArchiveContent(
          original_cache_trace_path, BuildPatchedCache.path)
      with open(ValidatePatchedCache.path, 'w') as output:
        json.dump(cache_validation_result, output)

    self._wpr_archive_path = BuildPatchedWpr.path
    self._trace_from_grabbing_reference_cache = original_cache_trace_path
    self._cache_path = BuildPatchedCache.path
    self._cache_validation_task = ValidatePatchedCache

    self._common_builder.default_final_tasks.append(ValidatePatchedCache)

  def PopulateLoadBenchmark(self, subresource_discoverer,
                            transformer_list_name, transformer_list):
    """Populate benchmarking tasks from its setup tasks.

    Args:
      subresource_discoverer: Name of a subresources discoverer.
      transformer_list_name: A string describing the transformers, will be used
          in Task names (prefer names without spaces and special characters).
      transformer_list: An ordered list of function that takes an instance of
          SandwichRunner as parameter, would be applied immediately before
          SandwichRunner.Run() in the given order.

    Here is the full dependency of the added tree for the returned task:
    <transformer_list_name>/<subresource_discoverer>-metrics.csv
      depends on: <transformer_list_name>/<subresource_discoverer>-run/
        depends on: common/<subresource_discoverer>-cache.zip
          depends on: common/<subresource_discoverer>-setup.json
            depends on: common/patched-cache-validation.json
    """
    additional_column_names = [
        'url',
        'repeat_id',
        'subresource_discoverer',
        'cache_recording.subresource_count',
        'cache_recording.cached_subresource_count_theoretic',
        'cache_recording.cached_subresource_count',
        'benchmark.subresource_count',
        'benchmark.served_from_cache_count_theoretic',
        'benchmark.served_from_cache_count',
        'benchmark.served_from_network_bytes',
        'benchmark.served_from_cache_bytes']

    assert subresource_discoverer in SUBRESOURCE_DISCOVERERS
    assert 'common' not in SUBRESOURCE_DISCOVERERS
    shared_task_prefix = os.path.join('common', subresource_discoverer)
    task_prefix = os.path.join(transformer_list_name, subresource_discoverer)

    @self.RegisterTask(shared_task_prefix + '-setup.json', merge=True,
                       dependencies=[self._cache_validation_task])
    def SetupBenchmark():
      whitelisted_urls = _ExtractDiscoverableUrls(
          original_headers_path=self._original_headers_path,
          loading_trace_path=self._trace_from_grabbing_reference_cache,
          subresource_discoverer=subresource_discoverer)

      common_util.EnsureParentDirectoryExists(SetupBenchmark.path)
      with open(SetupBenchmark.path, 'w') as output:
        json.dump({
            'cache_whitelist': [url for url in whitelisted_urls],
            'subresource_discoverer': subresource_discoverer,
          }, output)

    @self.RegisterTask(shared_task_prefix + '-cache.zip', merge=True,
                       dependencies=[SetupBenchmark])
    def BuildBenchmarkCacheArchive():
      benchmark_setup = json.load(open(SetupBenchmark.path))
      chrome_cache.ApplyUrlWhitelistToCacheArchive(
          cache_archive_path=self._cache_path,
          whitelisted_urls=benchmark_setup['cache_whitelist'],
          output_cache_archive_path=BuildBenchmarkCacheArchive.path)

    @self.RegisterTask(task_prefix + '-run/',
                       dependencies=[BuildBenchmarkCacheArchive])
    def RunBenchmark():
      runner = self._common_builder.CreateSandwichRunner()
      for transformer in transformer_list:
        transformer(runner)
      runner.wpr_archive_path = self._common_builder.original_wpr_task.path
      runner.wpr_out_log_path = os.path.join(
          RunBenchmark.path, sandwich_runner.WPR_LOG_FILENAME)
      runner.cache_archive_path = BuildBenchmarkCacheArchive.path
      runner.cache_operation = sandwich_runner.CacheOperation.PUSH
      runner.output_dir = RunBenchmark.path
      runner.Run()

    @self.RegisterTask(task_prefix + '-metrics.csv',
                       dependencies=[RunBenchmark])
    def ProcessRunOutputDir():
      benchmark_setup = json.load(open(SetupBenchmark.path))
      cache_validation_result = json.load(
          open(self._cache_validation_task.path))

      run_metrics_list = _ProcessRunOutputDir(
          cache_validation_result, benchmark_setup, RunBenchmark.path)
      with open(ProcessRunOutputDir.path, 'w') as csv_file:
        writer = csv.DictWriter(csv_file, fieldnames=(additional_column_names +
                                    sandwich_metrics.COMMON_CSV_COLUMN_NAMES))
        writer.writeheader()
        for trace_metrics in run_metrics_list:
          writer.writerow(trace_metrics)

    self._common_builder.default_final_tasks.append(ProcessRunOutputDir)