Merge all logic in PageMeasurementResults to PageTestResults.

This consists of:
1) Deletion of WillMeasurePage/DidMeasurePage and
page_specific_results_for_current_page (which does not
make sense since a results can be added any time between
StartTest/StopTest.
2) Moving trace_tag and current_page property to PageTestResults;
current_page is filled at StartTest and reset at StopTest.

The class itself will be deleted separately after all
of its subclasses are deleted or switched to OutputFormatter
(as per thread on telemetry@chromium.org).

BUG=383635

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

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

tools/perf/measurements/page_cycler_unittest.py

@@ -140,19 +140,18 @@ class PageCyclerUnitTest(unittest.TestCase):
     url_name = 'http://fakepage.com'
     page = FakePage(url_name)
     tab = FakeTab()
-    results = page_measurement_results.PageMeasurementResults()
 
     for i in range(5):
+      results = page_measurement_results.PageMeasurementResults()
+      results.StartTest(page)
       cycler.WillNavigateToPage(page, tab)
       self.assertEqual(max(0, i - 2), tab.clear_cache_calls,
                        'Iteration %d tab.clear_cache_calls %d' %
                        (i, tab.clear_cache_calls))
-      results.WillMeasurePage(page)
       cycler.MeasurePage(page, tab, results)
+      results.StopTest(page)
 
-      values = results.page_specific_values_for_current_page
-      results.DidMeasurePage()
-
+      values = results.all_page_specific_values
       self.assertGreater(len(values), 2)
 
       self.assertEqual(values[0].page, page)
@@ -166,16 +165,15 @@ class PageCyclerUnitTest(unittest.TestCase):
     cycler = self.SetUpCycler(['--pageset-repeat=3'], True)
     pages = [FakePage('http://fakepage1.com'), FakePage('http://fakepage2.com')]
     tab = FakeTab()
-    results = page_measurement_results.PageMeasurementResults()
     for i in range(3):
       for page in pages:
+        results = page_measurement_results.PageMeasurementResults()
+        results.StartTest(page)
         cycler.WillNavigateToPage(page, tab)
-        results.WillMeasurePage(page)
         cycler.MeasurePage(page, tab, results)
+        results.StopTest(page)
 
-        values = results.page_specific_values_for_current_page
-        results.DidMeasurePage()
-
+        values = results.all_page_specific_values
         self.assertGreater(len(values), 2)
 
         self.assertEqual(values[0].page, page)
@@ -191,17 +189,16 @@ class PageCyclerUnitTest(unittest.TestCase):
 
     pages = [FakePage('http://fakepage1.com'), FakePage('http://fakepage2.com')]
     tab = FakeTab()
-    results = page_measurement_results.PageMeasurementResults()
 
     for i in range(2):
       for page in pages:
+        results = page_measurement_results.PageMeasurementResults()
+        results.StartTest(page)
         cycler.WillNavigateToPage(page, tab)
-        results.WillMeasurePage(page)
         cycler.MeasurePage(page, tab, results)
+        results.StopTest(page)
 
-        values = results.page_specific_values_for_current_page
-        results.DidMeasurePage()
-
+        values = results.all_page_specific_values
         self.assertEqual(4, len(values))
 
         self.assertEqual(values[0].page, page)
@@ -215,5 +212,4 @@ class PageCyclerUnitTest(unittest.TestCase):
                            'cpu_utilization.cpu_utilization_%s' % expected)
           self.assertEqual(value.units, '%')
 
-
         cycler.DidNavigateToPage(page, tab)

tools/perf/metrics/test_page_measurement_results.py

@@ -13,7 +13,7 @@ class TestPageMeasurementResults(
     super(TestPageMeasurementResults, self).__init__()
     self.test = test
     page = page_module.Page("http://www.google.com", {})
-    self.WillMeasurePage(page)
+    self.StartTest(page)
 
   def GetPageSpecificValueNamed(self, name):
     values = [value for value in self.all_page_specific_values

tools/telemetry/telemetry/page/page_measurement.py

@@ -57,11 +57,7 @@ class PageMeasurement(page_test.PageTest):
       is_action_name_to_run_optional=is_action_name_to_run_optional)
 
   def ValidatePage(self, page, tab, results):
-    results.WillMeasurePage(page)
-    try:
-      self.MeasurePage(page, tab, results)
-    finally:
-      results.DidMeasurePage()
+    self.MeasurePage(page, tab, results)
 
   def MeasurePage(self, page, tab, results):
     """Override to actually measure the page's performance.

tools/telemetry/telemetry/results/block_page_measurement_results_unittest.py

@@ -43,15 +43,15 @@ class BlockPageMeasurementResultsTest(unittest.TestCase):
 
   def testOutput(self):
     results = NonPrintingBlockPageMeasurementResults(self._output)
-    results.WillMeasurePage(self._page_set[0])
+    results.StartTest(self._page_set[0])
     results.AddValue(
         scalar.ScalarValue(self._page_set[0], 'foo', 'seconds', 3))
-    results.DidMeasurePage()
+    results.StopTest(self._page_set[0])
 
-    results.WillMeasurePage(self._page_set[1])
+    results.StartTest(self._page_set[1])
     results.AddValue(
         scalar.ScalarValue(self._page_set[1], 'bar', 'seconds', 4))
-    results.DidMeasurePage()
+    results.StopTest(self._page_set[1])
 
     results.PrintSummary()
     expected = [

tools/telemetry/telemetry/results/csv_page_measurement_results_unittest.py

@@ -48,12 +48,12 @@ class CsvPageMeasurementResultsTest(unittest.TestCase):
 
   def test_with_no_results_on_second_run(self):
     results = NonPrintingCsvPageMeasurementResults(self._output)
-    results.WillMeasurePage(self._page_set[0])
+    results.StartTest(self._page_set[0])
     results.AddValue(scalar.ScalarValue(self._page_set[0], 'foo', 'seconds', 3))
-    results.DidMeasurePage()
+    results.StopTest(self._page_set[0])
 
-    results.WillMeasurePage(self._page_set[1])
-    results.DidMeasurePage()
+    results.StartTest(self._page_set[1])
+    results.StopTest(self._page_set[1])
 
     results.PrintSummary()
     self.assertEqual(['page_name', 'foo (seconds)'], self.output_header_row)
@@ -64,14 +64,14 @@ class CsvPageMeasurementResultsTest(unittest.TestCase):
 
   def test_fewer_results_on_second_run(self):
     results = NonPrintingCsvPageMeasurementResults(self._output)
-    results.WillMeasurePage(self._page_set[0])
+    results.StartTest(self._page_set[0])
     results.AddValue(scalar.ScalarValue(self._page_set[0], 'foo', 'seconds', 3))
     results.AddValue(scalar.ScalarValue(self._page_set[0], 'bar', 'seconds', 4))
-    results.DidMeasurePage()
+    results.StopTest(self._page_set[0])
 
-    results.WillMeasurePage(self._page_set[1])
+    results.StartTest(self._page_set[1])
     results.AddValue(scalar.ScalarValue(self._page_set[1], 'bar', 'seconds', 5))
-    results.DidMeasurePage()
+    results.StopTest(self._page_set[1])
 
     results.PrintSummary()
     self.assertEqual(['page_name', 'bar (seconds)', 'foo (seconds)'],
@@ -82,13 +82,13 @@ class CsvPageMeasurementResultsTest(unittest.TestCase):
 
   def test_with_output_at_print_summary_time(self):
     results = NonPrintingCsvPageMeasurementResults(self._output)
-    results.WillMeasurePage(self._page_set[0])
+    results.StartTest(self._page_set[0])
     results.AddValue(scalar.ScalarValue(self._page_set[0], 'foo', 'seconds', 3))
-    results.DidMeasurePage()
+    results.StopTest(self._page_set[0])
 
-    results.WillMeasurePage(self._page_set[1])
+    results.StartTest(self._page_set[1])
     results.AddValue(scalar.ScalarValue(self._page_set[1], 'bar', 'seconds', 4))
-    results.DidMeasurePage()
+    results.StopTest(self._page_set[1])
 
     results.PrintSummary()
 
@@ -102,17 +102,17 @@ class CsvPageMeasurementResultsTest(unittest.TestCase):
 
   def test_histogram(self):
     results = NonPrintingCsvPageMeasurementResults(self._output)
-    results.WillMeasurePage(self._page_set[0])
+    results.StartTest(self._page_set[0])
     results.AddValue(histogram.HistogramValue(
         self._page_set[0], 'a', '',
         raw_value_json='{"buckets": [{"low": 1, "high": 2, "count": 1}]}'))
-    results.DidMeasurePage()
+    results.StopTest(self._page_set[0])
 
-    results.WillMeasurePage(self._page_set[1])
+    results.StartTest(self._page_set[1])
     results.AddValue(histogram.HistogramValue(
         self._page_set[1], 'a', '',
         raw_value_json='{"buckets": [{"low": 2, "high": 3, "count": 1}]}'))
-    results.DidMeasurePage()
+    results.StopTest(self._page_set[1])
 
     results.PrintSummary()
 

tools/telemetry/telemetry/results/html_page_measurement_results_unittest.py

@@ -41,17 +41,17 @@ class HtmlPageMeasurementResultsTest(unittest.TestCase):
     # Run the first time and verify the results are written to the HTML file.
     results = DeterministicHtmlPageMeasurementResults(
         output_file, 'test_name', False, False, 'browser_type')
-    results.WillMeasurePage(test_page_set.pages[0])
+    results.StartTest(test_page_set.pages[0])
     results.AddValue(scalar.ScalarValue(
         test_page_set.pages[0], 'a', 'seconds', 3))
-    results.DidMeasurePage()
     results.AddSuccess(test_page_set.pages[0])
+    results.StopTest(test_page_set.pages[0])
 
-    results.WillMeasurePage(test_page_set.pages[1])
+    results.StartTest(test_page_set.pages[1])
     results.AddValue(scalar.ScalarValue(
         test_page_set.pages[1], 'a', 'seconds', 7))
-    results.DidMeasurePage()
     results.AddSuccess(test_page_set.pages[1])
+    results.StopTest(test_page_set.pages[1])
 
     results.PrintSummary()
     results.GetResults()
@@ -98,17 +98,17 @@ class HtmlPageMeasurementResultsTest(unittest.TestCase):
     output_file.seek(0)
     results = DeterministicHtmlPageMeasurementResults(
         output_file, 'test_name', False, False, 'browser_type')
-    results.WillMeasurePage(test_page_set.pages[0])
+    results.StartTest(test_page_set.pages[0])
     results.AddValue(scalar.ScalarValue(
         test_page_set.pages[0], 'a', 'seconds', 4))
-    results.DidMeasurePage()
     results.AddSuccess(test_page_set.pages[0])
+    results.StopTest(test_page_set.pages[0])
 
-    results.WillMeasurePage(test_page_set.pages[1])
+    results.StartTest(test_page_set.pages[1])
     results.AddValue(scalar.ScalarValue(
         test_page_set.pages[1], 'a', 'seconds', 8))
-    results.DidMeasurePage()
     results.AddSuccess(test_page_set.pages[1])
+    results.StopTest(test_page_set.pages[1])
 
     results.PrintSummary()
     expected = [
@@ -193,17 +193,17 @@ class HtmlPageMeasurementResultsTest(unittest.TestCase):
     output_file.seek(0)
     results = DeterministicHtmlPageMeasurementResults(
        output_file, 'test_name', True, False, 'browser_type')
-    results.WillMeasurePage(test_page_set.pages[0])
+    results.StartTest(test_page_set.pages[0])
     results.AddValue(scalar.ScalarValue(
         test_page_set.pages[0], 'a', 'seconds', 5))
-    results.DidMeasurePage()
     results.AddSuccess(test_page_set.pages[0])
+    results.StopTest(test_page_set.pages[0])
 
-    results.WillMeasurePage(test_page_set.pages[1])
+    results.StartTest(test_page_set.pages[1])
     results.AddValue(scalar.ScalarValue(
         test_page_set.pages[1], 'a', 'seconds', 9))
-    results.DidMeasurePage()
     results.AddSuccess(test_page_set.pages[1])
+    results.StopTest(test_page_set.pages[1])
 
     results.PrintSummary()
     expected = [{

tools/telemetry/telemetry/results/page_measurement_results.py

@@ -3,36 +3,8 @@
 # found in the LICENSE file.
 
 from telemetry.results import page_test_results
-from telemetry.value import failure
 
 class PageMeasurementResults(page_test_results.PageTestResults):
   def __init__(self, output_stream=None, trace_tag=''):
-    super(PageMeasurementResults, self).__init__(output_stream)
+    super(PageMeasurementResults, self).__init__(output_stream, trace_tag)
     self._trace_tag = trace_tag
-
-    self._current_page = None
-    self._page_specific_values_for_current_page = None
-
-  @property
-  def current_page(self):
-    return self._current_page
-
-  @property
-  def page_specific_values_for_current_page(self):
-    assert self._current_page
-    return self._page_specific_values_for_current_page
-
-  def WillMeasurePage(self, page):
-    assert not self._current_page
-    self._current_page = page
-    self._page_specific_values_for_current_page = []
-
-  def AddValue(self, value):
-    super(PageMeasurementResults, self).AddValue(value)
-    if not isinstance(value, failure.FailureValue):
-      self._page_specific_values_for_current_page.append(value)
-
-  def DidMeasurePage(self):
-    assert self._current_page, 'Failed to call WillMeasurePage'
-    self._current_page = None
-    self._page_specific_values_for_current_page = None

tools/telemetry/telemetry/results/page_measurement_results_unittest.py

@@ -47,13 +47,13 @@ class PageMeasurementResultsTest(unittest.TestCase):
 
   def test_basic(self):
     results = NonPrintingPageMeasurementResults()
-    results.WillMeasurePage(self.pages[0])
+    results.StartTest(self.pages[0])
     results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
-    results.DidMeasurePage()
+    results.StopTest(self.pages[0])
 
-    results.WillMeasurePage(self.pages[1])
+    results.StartTest(self.pages[1])
     results.AddValue(scalar.ScalarValue(self.pages[1], 'a', 'seconds', 3))
-    results.DidMeasurePage()
+    results.StopTest(self.pages[1])
 
     results.PrintSummary()
 
@@ -68,7 +68,7 @@ class PageMeasurementResultsTest(unittest.TestCase):
 
   def test_url_is_invalid_value(self):
     results = NonPrintingPageMeasurementResults()
-    results.WillMeasurePage(self.pages[0])
+    results.StartTest(self.pages[0])
     self.assertRaises(
       AssertionError,
       lambda: results.AddValue(scalar.ScalarValue(
@@ -76,7 +76,7 @@ class PageMeasurementResultsTest(unittest.TestCase):
 
   def test_add_summary_value_with_page_specified(self):
     results = NonPrintingPageMeasurementResults()
-    results.WillMeasurePage(self.pages[0])
+    results.StartTest(self.pages[0])
     self.assertRaises(
       AssertionError,
       lambda: results.AddSummaryValue(scalar.ScalarValue(self.pages[0],
@@ -84,11 +84,11 @@ class PageMeasurementResultsTest(unittest.TestCase):
 
   def test_unit_change(self):
     results = NonPrintingPageMeasurementResults()
-    results.WillMeasurePage(self.pages[0])
+    results.StartTest(self.pages[0])
     results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
-    results.DidMeasurePage()
+    results.StopTest(self.pages[0])
 
-    results.WillMeasurePage(self.pages[1])
+    results.StartTest(self.pages[1])
     self.assertRaises(
       AssertionError,
       lambda: results.AddValue(scalar.ScalarValue(
@@ -96,11 +96,11 @@ class PageMeasurementResultsTest(unittest.TestCase):
 
   def test_type_change(self):
     results = NonPrintingPageMeasurementResults()
-    results.WillMeasurePage(self.pages[0])
+    results.StartTest(self.pages[0])
     results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
-    results.DidMeasurePage()
+    results.StopTest(self.pages[0])
 
-    results.WillMeasurePage(self.pages[1])
+    results.StartTest(self.pages[1])
     self.assertRaises(
       AssertionError,
       lambda: results.AddValue(histogram.HistogramValue(
@@ -110,14 +110,14 @@ class PageMeasurementResultsTest(unittest.TestCase):
   def test_basic_summary_all_pages_fail(self):
     """If all pages fail, no summary is printed."""
     results = SummarySavingPageMeasurementResults()
-    results.WillMeasurePage(self.pages[0])
+    results.StartTest(self.pages[0])
     results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
-    results.DidMeasurePage()
+    results.StopTest(self.pages[0])
     results.AddValue(failure.FailureValue.FromMessage(self.pages[0], 'message'))
 
-    results.WillMeasurePage(self.pages[1])
+    results.StartTest(self.pages[1])
     results.AddValue(scalar.ScalarValue(self.pages[1], 'a', 'seconds', 7))
-    results.DidMeasurePage()
+    results.StopTest(self.pages[1])
     results.AddValue(failure.FailureValue.FromMessage(self.pages[1], 'message'))
 
     results.PrintSummary()
@@ -125,50 +125,47 @@ class PageMeasurementResultsTest(unittest.TestCase):
 
   def test_get_successful_page_values_merged_no_failures(self):
     results = SummarySavingPageMeasurementResults()
-    results.WillMeasurePage(self.pages[0])
+    results.StartTest(self.pages[0])
     results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
-    self.assertEquals(1, len(results.page_specific_values_for_current_page))
-    results.DidMeasurePage()
-    self.assertRaises(
-        AssertionError,
-        lambda: results.page_specific_values_for_current_page)
+    self.assertEquals(1, len(results.all_page_specific_values))
+    results.StopTest(self.pages[0])
 
   def test_get_all_values_for_successful_pages(self):
     results = SummarySavingPageMeasurementResults()
-    results.WillMeasurePage(self.pages[0])
+    results.StartTest(self.pages[0])
     value1 = scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3)
     results.AddValue(value1)
-    results.DidMeasurePage()
+    results.StopTest(self.pages[0])
 
-    results.WillMeasurePage(self.pages[1])
+    results.StartTest(self.pages[1])
     value2 = scalar.ScalarValue(self.pages[1], 'a', 'seconds', 3)
     results.AddValue(value2)
-    results.DidMeasurePage()
+    results.StopTest(self.pages[1])
 
-    results.WillMeasurePage(self.pages[2])
+    results.StartTest(self.pages[2])
     value3 = scalar.ScalarValue(self.pages[2], 'a', 'seconds', 3)
     results.AddValue(value3)
-    results.DidMeasurePage()
+    results.StopTest(self.pages[2])
 
     self.assertEquals(
         [value1, value2, value3], results.all_page_specific_values)
 
   def test_get_all_values_for_successful_pages_one_page_fails(self):
     results = SummarySavingPageMeasurementResults()
-    results.WillMeasurePage(self.pages[0])
+    results.StartTest(self.pages[0])
     value1 = scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3)
     results.AddValue(value1)
-    results.DidMeasurePage()
+    results.StopTest(self.pages[0])
 
-    results.WillMeasurePage(self.pages[1])
+    results.StartTest(self.pages[1])
     value2 = failure.FailureValue.FromMessage(self.pages[1], 'Failure')
     results.AddValue(value2)
-    results.DidMeasurePage()
+    results.StopTest(self.pages[1])
 
-    results.WillMeasurePage(self.pages[2])
+    results.StartTest(self.pages[2])
     value3 = scalar.ScalarValue(self.pages[2], 'a', 'seconds', 3)
     results.AddValue(value3)
-    results.DidMeasurePage()
+    results.StopTest(self.pages[2])
 
     self.assertEquals(
         [value1, value2, value3], results.all_page_specific_values)

tools/telemetry/telemetry/results/page_test_results.py

@@ -11,9 +11,12 @@ from telemetry import value as value_module
 from telemetry.value import failure
 
 class PageTestResults(object):
-  def __init__(self, output_stream=None):
+  def __init__(self, output_stream=None, trace_tag=''):
     super(PageTestResults, self).__init__()
     self._output_stream = output_stream
+    self._trace_tag = trace_tag
+    self._current_page = None
+
     # TODO(chrishenry,eakuefner): Remove self.successes once they can
     # be inferred.
     self.successes = []
@@ -40,6 +43,10 @@ class PageTestResults(object):
   def all_summary_values(self):
     return self._all_summary_values
 
+  @property
+  def current_page(self):
+    return self._current_page
+
   @property
   def pages_that_succeeded(self):
     """Returns the set of pages that succeeded."""
@@ -61,10 +68,10 @@ class PageTestResults(object):
     return ''.join(traceback.format_exception(*err))
 
   def StartTest(self, page):
-    pass
+    self._current_page = page
 
-  def StopTest(self, page):
-    pass
+  def StopTest(self, page):  # pylint: disable=W0613
+    self._current_page = None
 
   def AddValue(self, value):
     self._ValidateValue(value)

tools/telemetry/telemetry/web_perf/metrics/fast_metric_unittest.py

@@ -42,9 +42,10 @@ class RendererThreadHelper(object):
         for s in self._async_slices]
     results = page_measurement_results.PageMeasurementResults()
     fake_page = None
-    results.WillMeasurePage(fake_page)
+    results.StartTest(fake_page)
     metric.AddResults(self._model, self._renderer_thread, interaction_records,
                       results)
+    results.StopTest(fake_page)
     return results
 
 

tools/telemetry/telemetry/web_perf/timeline_based_measurement_unittest.py

@@ -70,6 +70,7 @@ class TimelineBasedMetricTestData(object):
     self._renderer_thread.name = 'CrRendererMain'
     self._results = page_measurement_results.PageMeasurementResults()
     self._metric = None
+    self._ps = None
 
   @property
   def results(self):
@@ -89,13 +90,13 @@ class TimelineBasedMetricTestData(object):
     self._model.FinalizeImport()
     self._metric = tbm_module._TimelineBasedMetrics(  # pylint: disable=W0212
         self._model, self._renderer_thread, GetMetricFromMetricType)
-    ps = page_set.PageSet(file_path=os.path.dirname(__file__))
-    ps.AddPageWithDefaultRunNavigate('http://www.bar.com/')
-    self._results.WillMeasurePage(ps.pages[0])
+    self._ps = page_set.PageSet(file_path=os.path.dirname(__file__))
+    self._ps.AddPageWithDefaultRunNavigate('http://www.bar.com/')
+    self._results.StartTest(self._ps.pages[0])
 
   def AddResults(self):
     self._metric.AddResults(self._results)
-    self._results.DidMeasurePage()
+    self._results.StopTest(self._ps.pages[0])
 
 
 class TimelineBasedMetricsTests(unittest.TestCase):