[telemetry] More fixes for my page_test_result rewrite

TBR=tonyg@chromium.org
NOTRY=True

Review URL: https://chromiumcodereview.appspot.com/11783056

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@175770 0039d316-1c4b-4281-b951-d872f2087c98

tools/perf/perf_tools/skpicture_printer_unittest.py

@@ -32,7 +32,7 @@ class SkPicturePrinterUnitTest(
     self.assertEqual(1, len(all_results.page_results))
     results0 = all_results.page_results[0]
 
-    outdir = results0['output_path']
+    outdir = results0['output_path'].value
     self.assertTrue('non_scrollable_page_html' in outdir)
     self.assertTrue(os.path.isdir(outdir))
     self.assertEqual(['layer_0.skp'], os.listdir(outdir))

tools/perf/perf_tools/smoothness_benchmark_unittest.py

 # Copyright (c) 2012 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 telemetry import multi_page_benchmark
 from telemetry import multi_page_benchmark_unittest_base
 from telemetry import page
 from perf_tools import smoothness_benchmark
 
 from telemetry import browser_finder
 from telemetry import options_for_unittests
+from telemetry.page_benchmark_results import PageBenchmarkResults
 
 import os
 import urlparse
@@ -48,12 +48,14 @@ class SmoothnessBenchmarkUnitTest(
                        'totalTimeInSeconds': 1,
                        'numAnimationFrames': 10,
                        'numFramesSentToScreen': 10}
-    res = multi_page_benchmark.BenchmarkResults()
+    res = PageBenchmarkResults()
     res.WillMeasurePage(page.Page('http://foo.com/'))
     smoothness_benchmark.CalcScrollResults(rendering_stats, res)
     res.DidMeasurePage()
-    self.assertEquals(50, res.page_results[0]['dropped_percent'])
-    self.assertAlmostEquals(100, res.page_results[0]['mean_frame_time'], 2)
+    self.assertEquals(50, res.page_results[0]['dropped_percent'].value)
+    self.assertAlmostEquals(
+      100,
+      res.page_results[0]['mean_frame_time'].value, 2)
 
   def testCalcResultsRealRenderStats(self):
     rendering_stats = {'numFramesSentToScreen': 60,
@@ -68,12 +70,14 @@ class SmoothnessBenchmarkUnitTest(
                        'totalTextureUploadTimeInSeconds': 0,
                        'totalRasterizeTimeInSeconds': 0,
                        'totalTimeInSeconds': 1.0}
-    res = multi_page_benchmark.BenchmarkResults()
+    res = PageBenchmarkResults()
     res.WillMeasurePage(page.Page('http://foo.com/'))
     smoothness_benchmark.CalcScrollResults(rendering_stats, res)
     res.DidMeasurePage()
-    self.assertEquals(0, res.page_results[0]['dropped_percent'])
-    self.assertAlmostEquals(1000/60., res.page_results[0]['mean_frame_time'], 2)
+    self.assertEquals(0, res.page_results[0]['dropped_percent'].value)
+    self.assertAlmostEquals(
+      1000/60.,
+      res.page_results[0]['mean_frame_time'].value, 2)
 
   def testBoundingClientRect(self):
     options = options_for_unittests.GetCopy()
@@ -128,7 +132,7 @@ class SmoothnessBenchmarkUnitTest(
     all_results = self.RunBenchmark(benchmark, ps)
 
     results0 = all_results.page_results[0]
-    self.assertTrue(results0['percent_impl_scrolled'] > 0)
+    self.assertTrue(results0['percent_impl_scrolled'].value > 0)
 
   def testScrollingWithoutGpuBenchmarkingExtension(self):
     ps = self.CreatePageSetFromFileInUnittestDataDir('scrollable_page.html')

tools/telemetry/telemetry/csv_page_benchmark_results.py

@@ -29,7 +29,7 @@ class CsvPageBenchmarkResults(PageBenchmarkResults):
   def PrintSummary(self, trace_tag):
     if not self._output_after_every_page:
       self._OutputHeader()
-      for page_values in self.all_values_for_all_pages:
+      for page_values in self.page_results:
         self._OutputValuesForPage(page_values)
 
     super(CsvPageBenchmarkResults, self).PrintSummary(trace_tag)

tools/telemetry/telemetry/multi_page_benchmark_unittest.py

@@ -78,7 +78,8 @@ class MultiPageBenchmarkUnitTest(
     benchmark = BenchThatHasDefaults()
     all_results = self.RunBenchmark(benchmark, ps, options=self._options)
     self.assertEquals(len(all_results.page_results), 1)
-    self.assertEquals(all_results.page_results[0]['x'], 7)
+    self.assertEquals(
+      all_results.page_results[0].FindValueByTraceName('x').value, 7)
 
   def testRecordAndReplay(self):
     test_archive = '/tmp/google.wpr'

tools/telemetry/telemetry/multi_page_benchmark_unittest_base.py

@@ -5,10 +5,10 @@ import os
 import unittest
 
 from telemetry import browser_finder
-from telemetry import multi_page_benchmark
 from telemetry import options_for_unittests
 from telemetry import page_runner
 from telemetry import page as page_module
+from telemetry import page_benchmark_results
 from telemetry import page_set
 
 class MultiPageBenchmarkUnitTestBase(unittest.TestCase):
@@ -22,7 +22,7 @@ class MultiPageBenchmarkUnitTestBase(unittest.TestCase):
   def CreatePageSet(self, test_filename):
     base_dir = os.path.dirname(__file__)
     page = page_module.Page(test_filename, base_dir=base_dir)
-    setattr(page, 'scrolling', {'action': 'scrolling_interaction'})
+    setattr(page, 'smoothness', {'action': 'scrolling_interaction'})
     ps = page_set.PageSet(base_dir=base_dir)
     ps.pages.append(page)
     return ps
@@ -43,7 +43,7 @@ class MultiPageBenchmarkUnitTestBase(unittest.TestCase):
     benchmark.CustomizeBrowserOptions(options)
     possible_browser = browser_finder.FindBrowser(options)
 
-    results = multi_page_benchmark.BenchmarkResults()
+    results = page_benchmark_results.PageBenchmarkResults()
     with page_runner.PageRunner(ps) as runner:
       runner.Run(options, possible_browser, benchmark, results)
     return results

tools/telemetry/telemetry/page_benchmark_results.py

@@ -26,22 +26,43 @@ class ValuesForSinglePage(object):
       return values[0]
     return None
 
+  def __getitem__(self, trace_name):
+    return self.FindValueByTraceName(trace_name)
+
+  def __contains__(self, trace_name):
+    return self.FindValueByTraceName(trace_name) != None
+
+  def FindValueByTraceName(self, trace_name):
+    values = [value for value in self.values
+              if value.trace_name == trace_name]
+    assert len(values) <= 1
+    if len(values):
+      return values[0]
+    return None
+
 class PageBenchmarkResults(PageTestResults):
   def __init__(self):
     super(PageBenchmarkResults, self).__init__()
-    self._all_values_for_all_pages = []
+    self._page_results = []
 
     self._all_measurements_that_have_been_seen = {}
 
     self._values_for_current_page = {}
 
+  def __getitem__(self, i):
+    """Shorthand for self.page_results[i]"""
+    return self._page_results[i]
+
+  def __len__(self):
+    return len(self._page_results)
+
   @property
   def values_for_current_page(self):
     return self._values_for_current_page
 
   @property
-  def all_values_for_all_pages(self):
-    return self._all_values_for_all_pages
+  def page_results(self):
+    return self._page_results
 
   def WillMeasurePage(self, page):
     self._values_for_current_page = ValuesForSinglePage(page)
@@ -74,7 +95,7 @@ class PageBenchmarkResults(PageTestResults):
 
   def DidMeasurePage(self):
     assert self._values_for_current_page, 'Failed to call WillMeasurePage'
-    self._all_values_for_all_pages.append(self._values_for_current_page)
+    self._page_results.append(self._values_for_current_page)
     self._values_for_current_page = None
 
   def _PrintPerfResult(self, measurement, trace, values, units,
@@ -89,7 +110,7 @@ class PageBenchmarkResults(PageTestResults):
     results_summary = defaultdict(list)
     for measurement_name in \
           self._all_measurements_that_have_been_seen.iterkeys():
-      for page_values in self._all_values_for_all_pages:
+      for page_values in self._page_results:
         value = page_values.FindValueByMeasurementName(measurement_name)
         if not value:
           continue

tools/telemetry/telemetry/page_runner.py

@@ -150,6 +150,7 @@ http://goto/read-src-internal, or create a new archive using record_wpr.
 
   def _RunPage(self, options, page, tab, test, results):
     if not test.CanRunForPage(page):
+      logging.warning('Skiping test: it cannot run for %s', page.url)
       results.AddSkippedPage(page, 'Test cannot run', '')
       return