telemetry: Delete loading measurement.

R=tonyg@chromium.org,dtu@chromium.org,nduca@chromium.org,nednguyen@google.com
BUG=423563

Review URL: https://codereview.chromium.org/661653003

Cr-Commit-Position: refs/heads/master@{#299820}

4 files changed, 0 insertions, 281 deletions

diff --git a/tools/perf/measurements/loading_measurement_analyzer.py b/tools/perf/measurements/loading_measurement_analyzer.py
deleted file mode 100755
index 37d97b3..0000000
--- a/tools/perf/measurements/loading_measurement_analyzer.py
+++ /dev/null
@@ -1,183 +0,0 @@
-#!/usr/bin/env python
-# Copyright 2013 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.
-
-"""Parses CSV output from the loading_measurement and outputs interesting stats.
-
-Example usage:
-$ tools/perf/run_measurement --browser=release \
-    --output-format=csv --output=/path/to/loading_measurement_output.csv \
-    loading_measurement tools/perf/page_sets/top_1m.py
-$ tools/perf/measurements/loading_measurement_analyzer.py \
-    --num-slowest-urls=100 --rank-csv-file=/path/to/top-1m.csv \
-    /path/to/loading_measurement_output.csv
-"""
-
-import collections
-import csv
-import heapq
-import optparse
-import os
-import re
-import sys
-
-
-class LoadingMeasurementAnalyzer(object):
-
-  def __init__(self, input_file, options):
-    self.ranks = {}
-    self.totals = collections.defaultdict(list)
-    self.maxes = collections.defaultdict(list)
-    self.avgs = collections.defaultdict(list)
-    self.load_times = []
-    self.cpu_times = []
-    self.network_percents = []
-    self.num_rows_parsed = 0
-    self.num_slowest_urls = options.num_slowest_urls
-    if options.rank_csv_file:
-      self._ParseRankCsvFile(os.path.expanduser(options.rank_csv_file))
-    self._ParseInputFile(input_file, options)
-    self._display_zeros = options.display_zeros
-
-  def _ParseInputFile(self, input_file, options):
-    with open(input_file, 'r') as csvfile:
-      row_dict = csv.DictReader(csvfile)
-      for row in row_dict:
-        if (options.rank_limit and
-            self._GetRank(row['url']) > options.rank_limit):
-          continue
-        cpu_time = 0
-        load_time = float(row['load_time (ms)'])
-        if load_time < 0:
-          print 'Skipping %s due to negative load time' % row['url']
-          continue
-        for key, value in row.iteritems():
-          if key in ('url', 'load_time (ms)', 'dom_content_loaded_time (ms)'):
-            continue
-          if not value or value == '-':
-            continue
-          value = float(value)
-          if not value:
-            continue
-          if '_avg' in key:
-            self.avgs[key].append((value, row['url']))
-          elif '_max' in key:
-            self.maxes[key].append((value, row['url']))
-          else:
-            self.totals[key].append((value, row['url']))
-            cpu_time += value
-        self.load_times.append((load_time, row['url']))
-        self.cpu_times.append((cpu_time, row['url']))
-        if options.show_network:
-          network_time = load_time - cpu_time
-          self.totals['Network (ms)'].append((network_time, row['url']))
-          self.network_percents.append((network_time / load_time, row['url']))
-        self.num_rows_parsed += 1
-        if options.max_rows and self.num_rows_parsed == int(options.max_rows):
-          break
-
-  def _ParseRankCsvFile(self, input_file):
-    with open(input_file, 'r') as csvfile:
-      for row in csv.reader(csvfile):
-        assert len(row) == 2
-        self.ranks[row[1]] = int(row[0])
-
-  def _GetRank(self, url):
-    url = url.replace('http://', '')
-    if url in self.ranks:
-      return self.ranks[url]
-    return len(self.ranks)
-
-  def PrintSummary(self, stdout):
-    sum_totals = {}
-    units = None
-    for key, values in self.totals.iteritems():
-      m = re.match('.* [(](.*)[)]', key)
-      assert m, 'All keys should have units.'
-      assert not units or units == m.group(1), 'All units should be the same.'
-      units = m.group(1)
-      sum_totals[key] = sum([v[0] for v in values])
-    total_cpu_time = sum([v[0] for v in self.cpu_times])
-    total_page_load_time = sum([v[0] for v in self.load_times])
-
-    print >> stdout
-    print >> stdout, 'Total URLs:', self.num_rows_parsed
-    print >> stdout, 'Total page load time: %ds' % int(round(
-        total_page_load_time / 1000))
-    print >> stdout, 'Average page load time: %dms' % int(round(
-        total_page_load_time / self.num_rows_parsed))
-    if units == 'ms':
-      print >> stdout, 'Total CPU time: %ds' % int(round(total_cpu_time / 1000))
-      print >> stdout, 'Average CPU time: %dms' % int(round(
-          total_cpu_time / self.num_rows_parsed))
-    print >> stdout
-    for key, value in sorted(sum_totals.iteritems(), reverse=True,
-                             key=lambda i: i[1]):
-      if not self._display_zeros and not int(value / 100.):
-        break
-      output_key = '%60s: ' % re.sub(' [(].*[)]', '', key)
-      if units == 'ms':
-        output_value = '%10ds ' % (value / 1000)
-        output_percent = '%.1f%%' % (100 * value / total_page_load_time)
-      else:
-        output_value = '%10d%s ' % (value, units)
-        output_percent = '%.1f%%' % (100 * value / total_cpu_time)
-      print >> stdout, output_key, output_value, output_percent
-
-    if not self.num_slowest_urls:
-      return
-
-    for key, values in sorted(self.totals.iteritems(), reverse=True,
-                              key=lambda i: sum_totals[i[0]]):
-      if not self._display_zeros and not int(sum_totals[key] / 100.):
-        break
-      print >> stdout
-      print >> stdout, 'Top %d slowest %s:' % (self.num_slowest_urls,
-                                               re.sub(' [(].*[)]', '', key))
-      slowest = heapq.nlargest(self.num_slowest_urls, values)
-      for value, url in slowest:
-        print >> stdout, '%10d%s\t%s (#%s)' % (value, units, url,
-                                               self._GetRank(url))
-
-    if self.network_percents:
-      print >> stdout
-      print >> stdout, 'Top %d highest network to CPU time ratios:' % (
-          self.num_slowest_urls)
-      for percent, url in sorted(
-          self.network_percents, reverse=True)[:self.num_slowest_urls]:
-        percent *= 100
-        print >> stdout, '\t', '%.1f%%' % percent, url, '(#%s)' % (
-            self._GetRank(url))
-
-
-def main(arguments, stdout=sys.stdout):
-  prog_desc = 'Parses CSV output from the loading_measurement'
-  parser = optparse.OptionParser(usage=('%prog [options]' + '\n\n' + prog_desc))
-
-  parser.add_option('--max-rows', type='int',
-                    help='Only process this many rows')
-  parser.add_option('--num-slowest-urls', type='int',
-                    help='Output this many slowest URLs for each category')
-  parser.add_option('--rank-csv-file', help='A CSV file of <rank,url>')
-  parser.add_option('--rank-limit', type='int',
-                    help='Only process pages higher than this rank')
-  parser.add_option('--show-network', action='store_true',
-                    help='Whether to display Network as a category')
-  parser.add_option('--display-zeros', action='store_true',
-                    help='Whether to display categories with zero time')
-
-  options, args = parser.parse_args(arguments)
-
-  assert len(args) == 1, 'Must pass exactly one CSV file to analyze'
-  if options.rank_limit and not options.rank_csv_file:
-    print 'Must pass --rank-csv-file with --rank-limit'
-    return 1
-
-  LoadingMeasurementAnalyzer(args[0], options).PrintSummary(stdout)
-
-  return 0
-
-
-if __name__ == '__main__':
-  sys.exit(main(sys.argv[1:]))
diff --git a/tools/perf/measurements/loading_measurement_analyzer_unittest.py b/tools/perf/measurements/loading_measurement_analyzer_unittest.py
deleted file mode 100644
index 26869b6..0000000
--- a/tools/perf/measurements/loading_measurement_analyzer_unittest.py
+++ /dev/null
@@ -1,34 +0,0 @@
-# Copyright 2013 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.
-import os
-import StringIO
-import unittest
-
-from measurements import loading_measurement_analyzer
-from telemetry.core import util
-
-class LoadingMeasurementAnalyzerUnitTest(unittest.TestCase):
-
-  # TODO(tonyg): Remove this backfill when we can assume python 2.7 everywhere.
-  def assertIn(self, first, second, _=None):
-    self.assertTrue(first in second,
-                    msg="'%s' not found in '%s'" % (first, second))
-
-  def testLoadingProfile(self):
-    output = StringIO.StringIO()
-    csv_path = os.path.join(
-        util.GetChromiumSrcDir(),
-        'tools', 'perf', 'measurements','test_data', 'loading_profile.csv')
-    loading_measurement_analyzer.main([csv_path], stdout=output)
-    output = output.getvalue()
-
-    # Get the summary right.
-    self.assertIn('Total URLs: 9', output)
-    self.assertIn('Total page load time: 51s', output)
-    self.assertIn('Average page load time: 5621ms', output)
-
-    # Spot check a few samples.
-    self.assertIn('WTF::IntHash::hash:  1359797948period  1.1%', output)
-    self.assertIn('WebCore::rangesIntersect:   648335678period  0.5%', output)
-    self.assertIn('v8::internal::Scanner::Scan:    19668346period  0.0', output)
diff --git a/tools/perf/measurements/loading_trace.py b/tools/perf/measurements/loading_trace.py
deleted file mode 100644
index 5475215..0000000
--- a/tools/perf/measurements/loading_trace.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright 2013 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.
-from measurements import timeline_controller
-from metrics import loading
-from metrics import timeline
-from telemetry.page import page_test
-from telemetry.web_perf import timeline_interaction_record as tir_module
-
-class LoadingTrace(page_test.PageTest):
-  def __init__(self, *args, **kwargs):
-    super(LoadingTrace, self).__init__(*args, **kwargs)
-    self._timeline_controller = timeline_controller.TimelineController()
-
-  def WillNavigateToPage(self, page, tab):
-    self._timeline_controller.SetUp(page, tab)
-    self._timeline_controller.Start(tab)
-
-  def ValidateAndMeasurePage(self, page, tab, results):
-    # In current telemetry tests, all tests wait for DocumentComplete state,
-    # but we need to wait for the load event.
-    tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 300)
-
-    # TODO(nduca): when crbug.com/168431 is fixed, modify the page sets to
-    # recognize loading as a toplevel action.
-    self._timeline_controller.Stop(tab)
-
-    loading.LoadingMetric().AddResults(tab, results)
-    timeline_metric = timeline.LoadTimesTimelineMetric()
-    renderer_thread = \
-        self._timeline_controller.model.GetRendererThreadFromTabId(tab.id)
-    record = tir_module.TimelineInteractionRecord(
-      "loading_trace_interaction", 0, float('inf'))
-    timeline_metric.AddResults(
-      self._timeline_controller.model,
-      renderer_thread,
-      [record],
-      results)
-
-  def CleanUpAfterPage(self, _, tab):
-    self._timeline_controller.CleanUp(tab)
diff --git a/tools/perf/measurements/loading_trace_unittest.py b/tools/perf/measurements/loading_trace_unittest.py
deleted file mode 100644
index 62ddb29..0000000
--- a/tools/perf/measurements/loading_trace_unittest.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright 2014 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.
-
-from measurements import loading_trace
-from telemetry.core import wpr_modes
-from telemetry.unittest import options_for_unittests
-from telemetry.unittest import page_test_test_case
-
-class LoadingTraceUnitTest(page_test_test_case.PageTestTestCase):
-  def setUp(self):
-    self._options = options_for_unittests.GetCopy()
-    self._options.browser_options.wpr_mode = wpr_modes.WPR_OFF
-
-  def testLoadingTraceBasic(self):
-    ps = self.CreatePageSetFromFileInUnittestDataDir('scrollable_page.html')
-    measurement = loading_trace.LoadingTrace()
-    trace_options = self._options
-    results = self.RunMeasurement(measurement, ps, options = trace_options)
-    self.assertEquals(0, len(results.failures))
-
-  def testCleanUpTrace(self):
-    self.TestTracingCleanedUp(loading_trace.LoadingTrace, self._options)