Revert 284459 "Add FailureValue and wire it through PageTestResu..."

Reverting in hopes of getting android telemetry_perf_unittests to
green. Here's output:
http://build.chromium.org/p/chromium.linux/builders/Android%20Tests/builds/14733/steps/telemetry_perf_unittests/logs/stdio

Unhandled exception while running file://scrollable_page.html

Traceback (most recent call last):
  _RunPage at tools/telemetry/telemetry/page/page_runner.py:533
    test.RunPage(page, page_state.tab, results)
  RunPage at tools/telemetry/telemetry/page/page_test.py:228
    self.WillRunActions(page, tab)
  WillRunActions at tools/perf/measurements/smoothness.py:26
    self._power_metric.Start(page, tab)
  Start at tools/perf/metrics/power.py:77
    self._browser.platform.StartMonitoringPower(self._browser)
  StartMonitoringPower at
  tools/telemetry/telemetry/core/platform/__init__.py:193
    self._platform_backend.StartMonitoringPower(browser)
  StartMonitoringPower at
  tools/telemetry/telemetry/core/platform/android_platform_backend.py:251
    self._powermonitor.StartMonitoringPower(browser)
  StartMonitoringPower at
  tools/telemetry/telemetry/core/platform/power_monitor/android_temperature_monitor.py:31
    self._power_monitor.StartMonitoringPower(browser)
  StartMonitoringPower at
  tools/telemetry/telemetry/core/platform/power_monitor/power_monitor_controller.py:29
    self._active_monitor.StartMonitoringPower(browser)
  StartMonitoringPower at
  tools/telemetry/telemetry/core/platform/power_monitor/android_dumpsys_power_monitor.py:33
    'Must call StopMonitoringPower().')
AssertionError: Must call StopMonitoringPower().


> Add FailureValue and wire it through PageTestResults.
> 
> BUG=392901
> 
> Review URL: https://codereview.chromium.org/399263003

TBR=chrishenry@google.com

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

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

tools/perf/measurements/skpicture_printer_unittest.py

@@ -9,7 +9,6 @@ from measurements import skpicture_printer
 from telemetry.page import page_measurement_unittest_base
 from telemetry.unittest import options_for_unittests
 from telemetry.unittest import test
-from telemetry.value import failure
 
 
 class SkpicturePrinterUnitTest(
@@ -29,8 +28,7 @@ class SkpicturePrinterUnitTest(
 
     # Picture printing is not supported on all platforms.
     if results.failures:
-      assert 'not supported' in failure.GetStringFromExcInfo(
-          results.failures[0].exc_info)
+      assert 'not supported' in results.failures[0][1]
       return
 
     saved_picture_count = results.FindAllPageSpecificValuesNamed(

tools/telemetry/telemetry/page/page_runner.py

@@ -27,7 +27,7 @@ from telemetry.page.actions import page_action
 from telemetry.results import results_options
 from telemetry.util import cloud_storage
 from telemetry.util import exception_formatter
-from telemetry.value import failure
+
 
 class _RunState(object):
   def __init__(self):
@@ -498,8 +498,7 @@ def _CheckArchives(page_set, pages, results):
 
   for page in pages_missing_archive_path + pages_missing_archive_data:
     results.StartTest(page)
-    results.AddValue(failure.FailureValue.FromMessage(
-        page, 'Page set archive doesn\'t exist.'))
+    results.AddFailureMessage(page, 'Page set archive doesn\'t exist.')
     results.StopTest(page)
 
   return [page for page in pages if page not in
@@ -522,7 +521,7 @@ def _RunPage(test, page, state, expectation, results, finder_options):
       results.AddSuccess(page)
     else:
       msg = 'Exception while running %s' % page.url
-      results.AddValue(failure.FailureValue(page, sys.exc_info()))
+      results.AddFailure(page, sys.exc_info())
     exception_formatter.PrintFormattedException(msg=msg)
 
   try:
@@ -542,7 +541,7 @@ def _RunPage(test, page, state, expectation, results, finder_options):
     else:
       exception_formatter.PrintFormattedException(
           msg='Failure while running %s' % page.url)
-      results.AddValue(failure.FailureValue(page, sys.exc_info()))
+      results.AddFailure(page, sys.exc_info())
   except (util.TimeoutException, exceptions.LoginException,
           exceptions.ProfilingException):
     ProcessError()
@@ -555,7 +554,7 @@ def _RunPage(test, page, state, expectation, results, finder_options):
   except Exception:
     exception_formatter.PrintFormattedException(
         msg='Unhandled exception while running %s' % page.url)
-    results.AddValue(failure.FailureValue(page, sys.exc_info()))
+    results.AddFailure(page, sys.exc_info())
   else:
     if expectation == 'fail':
       logging.warning('%s was expected to fail, but passed.\n', page.url)

tools/telemetry/telemetry/page/profile_generator.py

@@ -49,7 +49,7 @@ def GenerateProfiles(profile_creator_class, profile_creator_name, options):
   if results.failures:
     logging.warning('Some pages failed.')
     logging.warning('Failed pages:\n%s',
-                    '\n'.join(results.pages_that_had_failures))
+                    '\n'.join(zip(*results.failures)[0]))
     return 1
 
   # Everything is a-ok, move results to final destination.

tools/telemetry/telemetry/page/record_wpr.py

@@ -136,7 +136,7 @@ def Main(base_dir):
     logging.warning('Some pages failed. The recording has not been updated for '
                     'these pages.')
     logging.warning('Failed pages:\n%s', '\n'.join(
-        p.display_name for p in results.pages_that_had_failures))
+        p.display_name for p in zip(*results.failures)[0]))
 
   if results.skipped:
     logging.warning('Some pages were skipped. The recording has not been '

tools/telemetry/telemetry/results/block_page_measurement_results.py

@@ -18,11 +18,10 @@ class BlockPageMeasurementResults(
         return
       lines = ['name: %s' % values[0].page.display_name]
       for value in sorted(values, key=lambda x: x.name):
-        if value.GetRepresentativeString() is not None:
-          lines.append('%s (%s): %s' %
-                       (value.name,
-                        value.units,
-                        value.GetRepresentativeString()))
+        lines.append('%s (%s): %s' %
+                     (value.name,
+                      value.units,
+                      value.GetRepresentativeString()))
       for line in lines:
         self._output_stream.write(line)
         self._output_stream.write(os.linesep)

tools/telemetry/telemetry/results/buildbot_page_measurement_results.py

@@ -52,9 +52,6 @@ class BuildbotPageMeasurementResults(
     buildbot_value = value.GetBuildbotValue()
     buildbot_data_type = value.GetBuildbotDataType(
         output_context=value_module.PER_PAGE_RESULT_OUTPUT_CONTEXT)
-    if buildbot_value is None or buildbot_data_type is None:
-      return
-
     buildbot_measurement_name, buildbot_trace_name = (
         value.GetBuildbotMeasurementAndTraceNameForPerPageResult())
     self._PrintPerfResult(buildbot_measurement_name,
@@ -71,12 +68,10 @@ class BuildbotPageMeasurementResults(
     buildbot_value = value.GetBuildbotValue()
     buildbot_data_type = value.GetBuildbotDataType(
         output_context=value_module.COMPUTED_PER_PAGE_SUMMARY_OUTPUT_CONTEXT)
-    if buildbot_value is None or buildbot_data_type is None:
-      return
-
     buildbot_measurement_name, buildbot_trace_name = (
         value.GetBuildbotMeasurementAndTraceNameForComputedSummaryResult(
             self._trace_tag))
+
     self._PrintPerfResult(buildbot_measurement_name,
                           buildbot_trace_name,
                           buildbot_value, value.units, buildbot_data_type)

tools/telemetry/telemetry/results/buildbot_page_measurement_results_unittest.py

@@ -5,12 +5,11 @@ import os
 
 from telemetry import perf_tests_helper
 from telemetry.page import page_set
-from telemetry.results import base_test_results_unittest
-from telemetry.results import buildbot_page_measurement_results
-from telemetry.value import failure
 from telemetry.value import histogram
 from telemetry.value import list_of_scalar_values
 from telemetry.value import scalar
+from telemetry.results import base_test_results_unittest
+from telemetry.results import buildbot_page_measurement_results
 
 
 def _MakePageSet():
@@ -131,8 +130,7 @@ class BuildbotPageMeasurementResultsTest(
     measurement_results.AddValue(scalar.ScalarValue(
         test_page_set.pages[0], 'a', 'seconds', 3))
     measurement_results.DidMeasurePage()
-    measurement_results.AddValue(
-        failure.FailureValue.FromMessage(test_page_set.pages[0], 'message'))
+    measurement_results.AddFailureMessage(test_page_set.pages[0], 'message')
 
     measurement_results.WillMeasurePage(test_page_set.pages[1])
     measurement_results.AddValue(scalar.ScalarValue(
@@ -163,8 +161,7 @@ class BuildbotPageMeasurementResultsTest(
     measurement_results.AddValue(scalar.ScalarValue(
         test_page_set.pages[1], 'a', 'seconds', 7))
     measurement_results.DidMeasurePage()
-    measurement_results.AddValue(
-        failure.FailureValue.FromMessage(test_page_set.pages[1], 'message'))
+    measurement_results.AddFailureMessage(test_page_set.pages[1], 'message')
 
     measurement_results.WillMeasurePage(test_page_set.pages[0])
     measurement_results.AddValue(scalar.ScalarValue(

tools/telemetry/telemetry/results/gtest_test_results.py

@@ -6,7 +6,6 @@ import logging
 import time
 
 from telemetry.results import page_test_results
-from telemetry.value import failure
 
 
 class GTestTestResults(page_test_results.PageTestResults):
@@ -17,19 +16,20 @@ class GTestTestResults(page_test_results.PageTestResults):
   def _GetMs(self):
     return (time.time() - self._timestamp) * 1000
 
-  def _emitFailure(self, failure_value):
-    print >> self._output_stream, failure.GetStringFromExcInfo(
-        failure_value.exc_info)
-    display_name = failure_value.page.display_name
-    print >> self._output_stream, '[  FAILED  ]', display_name, (
+  def _emitFailure(self, page, err):
+    print >> self._output_stream, self._GetStringFromExcInfo(err)
+    print >> self._output_stream, '[  FAILED  ]', page.display_name, (
         '(%0.f ms)' % self._GetMs())
     self._output_stream.flush()
 
-  def AddValue(self, value):
-    assert isinstance(value, failure.FailureValue), (
-        'GTestTestResults only accepts FailureValue.')
-    super(GTestTestResults, self).AddValue(value)
-    self._emitFailure(value)
+  def ValidateValue(self, value):
+    # TODO(chrishenry): When FailureValue is added, this should instead
+    # validate that isinstance(value, FailureValue) is true.
+    raise Exception('GTestTestResults does not support AddValue().')
+
+  def AddFailure(self, page, err):
+    super(GTestTestResults, self).AddFailure(page, err)
+    self._emitFailure(page, err)
 
   def StartTest(self, page):
     super(GTestTestResults, self).StartTest(page)
@@ -61,9 +61,9 @@ class GTestTestResults(page_test_results.PageTestResults):
       unit = 'test' if len(self.failures) == 1 else 'tests'
       print >> self._output_stream, '[  FAILED  ]', (
           '%d %s, listed below:' % (len(self.failures), unit))
-      for failure_value in self.failures:
+      for page, _ in self.failures:
         print >> self._output_stream, '[  FAILED  ] ', (
-            failure_value.page.display_name)
+            page.display_name)
       print >> self._output_stream
       count = len(self.failures)
       unit = 'TEST' if count == 1 else 'TESTS'

tools/telemetry/telemetry/results/gtest_test_results_unittest.py

@@ -8,7 +8,6 @@ from telemetry.page import page_set
 from telemetry.results import base_test_results_unittest
 from telemetry.results import gtest_test_results
 from telemetry.unittest import simple_mock
-from telemetry.value import failure
 
 
 def _MakePageSet():
@@ -57,10 +56,10 @@ class GTestTestResultsTest(
 
     results = SummaryGtestTestResults()
     results.StartTest(test_page_set.pages[0])
-    exc_info = self.CreateException()
-    results.AddValue(failure.FailureValue(test_page_set.pages[0], exc_info))
+    exception = self.CreateException()
+    results.AddFailure(test_page_set.pages[0], exception)
     results.PrintSummary()
-    exception_trace = ''.join(traceback.format_exception(*exc_info))
+    exception_trace = ''.join(traceback.format_exception(*exception))
     expected = ('[ RUN      ] http://www.foo.com/\n'
                 '%s\n'
                 '[  FAILED  ] http://www.foo.com/ (0 ms)\n'
@@ -85,7 +84,7 @@ class GTestTestResultsTest(
   def testPassAndFailedPages(self):
     test_page_set = _MakePageSet()
     results = SummaryGtestTestResults()
-    exc_info = self.CreateException()
+    exception = self.CreateException()
 
     results.StartTest(test_page_set.pages[0])
     self._mock_timer.SetTime(0.007)
@@ -93,18 +92,18 @@ class GTestTestResultsTest(
 
     results.StartTest(test_page_set.pages[1])
     self._mock_timer.SetTime(0.009)
-    results.AddValue(failure.FailureValue(test_page_set.pages[1], exc_info))
+    results.AddFailure(test_page_set.pages[1], exception)
 
     results.StartTest(test_page_set.pages[2])
     self._mock_timer.SetTime(0.015)
-    results.AddValue(failure.FailureValue(test_page_set.pages[2], exc_info))
+    results.AddFailure(test_page_set.pages[2], exception)
 
     results.StartTest(test_page_set.pages[3])
     self._mock_timer.SetTime(0.020)
     results.AddSuccess(test_page_set.pages[3])
 
     results.PrintSummary()
-    exception_trace = ''.join(traceback.format_exception(*exc_info))
+    exception_trace = ''.join(traceback.format_exception(*exception))
     expected = ('[ RUN      ] http://www.foo.com/\n'
                 '[       OK ] http://www.foo.com/ (7 ms)\n'
                 '[ RUN      ] http://www.bar.com/\n'
@@ -125,7 +124,7 @@ class GTestTestResultsTest(
   def testStreamingResults(self):
     test_page_set = _MakePageSet()
     results = SummaryGtestTestResults()
-    exc_info = self.CreateException()
+    exception = self.CreateException()
 
     results.StartTest(test_page_set.pages[0])
     self._mock_timer.SetTime(0.007)
@@ -136,8 +135,8 @@ class GTestTestResultsTest(
 
     results.StartTest(test_page_set.pages[1])
     self._mock_timer.SetTime(0.009)
-    exception_trace = ''.join(traceback.format_exception(*exc_info))
-    results.AddValue(failure.FailureValue(test_page_set.pages[1], exc_info))
+    exception_trace = ''.join(traceback.format_exception(*exception))
+    results.AddFailure(test_page_set.pages[1], exception)
     expected = ('[ RUN      ] http://www.foo.com/\n'
                 '[       OK ] http://www.foo.com/ (7 ms)\n'
                 '[ RUN      ] http://www.bar.com/\n'

tools/telemetry/telemetry/results/page_measurement_results.py

@@ -3,7 +3,6 @@
 # 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=''):
@@ -29,8 +28,7 @@ class PageMeasurementResults(page_test_results.PageTestResults):
 
   def AddValue(self, value):
     super(PageMeasurementResults, self).AddValue(value)
-    if not isinstance(value, failure.FailureValue):
-      self._page_specific_values_for_current_page.append(value)
+    self._page_specific_values_for_current_page.append(value)
 
   def DidMeasurePage(self):
     assert self._current_page, 'Failed to call WillMeasurePage'

tools/telemetry/telemetry/results/page_measurement_results_unittest.py

@@ -7,7 +7,6 @@ import unittest
 from telemetry import perf_tests_helper
 from telemetry.page import page_set
 from telemetry.results import page_measurement_results
-from telemetry.value import failure
 from telemetry.value import histogram
 from telemetry.value import scalar
 
@@ -113,12 +112,12 @@ class PageMeasurementResultsTest(unittest.TestCase):
     results.WillMeasurePage(self.pages[0])
     results.AddValue(scalar.ScalarValue(self.pages[0], 'a', 'seconds', 3))
     results.DidMeasurePage()
-    results.AddValue(failure.FailureValue.FromMessage(self.pages[0], 'message'))
+    results.AddFailureMessage(self.pages[0], 'message')
 
     results.WillMeasurePage(self.pages[1])
     results.AddValue(scalar.ScalarValue(self.pages[1], 'a', 'seconds', 7))
     results.DidMeasurePage()
-    results.AddValue(failure.FailureValue.FromMessage(self.pages[1], 'message'))
+    results.AddFailureMessage(self.pages[1], 'message')
 
     results.PrintSummary()
     self.assertEquals(results.results, [])
@@ -159,7 +158,7 @@ class PageMeasurementResultsTest(unittest.TestCase):
     results.DidMeasurePage()
 
     results.WillMeasurePage(self.pages[1])
-    results.AddValue(failure.FailureValue.FromMessage(self.pages[1], 'Failure'))
+    results.AddFailureMessage(self.pages[1], "Failure")
     results.DidMeasurePage()
 
     results.WillMeasurePage(self.pages[2])
@@ -167,7 +166,6 @@ class PageMeasurementResultsTest(unittest.TestCase):
     results.DidMeasurePage()
 
     values = results.all_page_specific_values
-    self.assertEquals(3, len(values))
-    self.assertEquals(
-        [self.pages[0], self.pages[2]], results.pages_that_succeeded)
-    self.assertEquals([self.pages[1]], results.pages_that_had_failures)
+    self.assertEquals(2, len(values))
+    self.assertEquals([self.pages[0], self.pages[2]],
+                      [v.page for v in values])

tools/telemetry/telemetry/results/page_test_results.py

@@ -5,18 +5,18 @@
 import collections
 import copy
 import logging
+import sys
 import traceback
 
 from telemetry import value as value_module
-from telemetry.value import failure
 
 class PageTestResults(object):
   def __init__(self, output_stream=None):
     super(PageTestResults, self).__init__()
     self._output_stream = output_stream
-    # TODO(chrishenry,eakuefner): Remove self.successes once they can
-    # be inferred.
+    self.pages_that_had_failures = set()
     self.successes = []
+    self.failures = []
     self.skipped = []
 
     self._representative_value_for_each_value_name = {}
@@ -44,16 +44,7 @@ class PageTestResults(object):
   def pages_that_succeeded(self):
     pages = set([value.page for value in self._all_page_specific_values])
     pages.difference_update(self.pages_that_had_failures)
-    return list(pages)
-
-  @property
-  def pages_that_had_failures(self):
-    return list(set([v.page for v in self.failures]))
-
-  @property
-  def failures(self):
-    values = self._all_page_specific_values
-    return [v for v in values if isinstance(v, failure.FailureValue)]
+    return pages
 
   def _GetStringFromExcInfo(self, err):
     return ''.join(traceback.format_exception(*err))
@@ -65,15 +56,15 @@ class PageTestResults(object):
     pass
 
   def AddValue(self, value):
-    self._ValidateValue(value)
+    self.ValidateValue(value)
     self._all_page_specific_values.append(value)
 
   def AddSummaryValue(self, value):
     assert value.page is None
-    self._ValidateValue(value)
+    self.ValidateValue(value)
     self._all_summary_values.append(value)
 
-  def _ValidateValue(self, value):
+  def ValidateValue(self, value):
     assert isinstance(value, value_module.Value)
     if value.name not in self._representative_value_for_each_value_name:
       self._representative_value_for_each_value_name[value.name] = value
@@ -81,16 +72,26 @@ class PageTestResults(object):
         value.name]
     assert value.IsMergableWith(representative_value)
 
+  def AddFailure(self, page, err):
+    self.pages_that_had_failures.add(page)
+    self.failures.append((page, self._GetStringFromExcInfo(err)))
+
   def AddSkip(self, page, reason):
     self.skipped.append((page, reason))
 
   def AddSuccess(self, page):
     self.successes.append(page)
 
+  def AddFailureMessage(self, page, message):
+    try:
+      raise Exception(message)
+    except Exception:
+      self.AddFailure(page, sys.exc_info())
+
   def PrintSummary(self):
     if self.failures:
       logging.error('Failed pages:\n%s', '\n'.join(
-          p.display_name for p in self.pages_that_had_failures))
+          p.display_name for p in zip(*self.failures)[0]))
 
     if self.skipped:
       logging.warning('Skipped pages:\n%s', '\n'.join(

tools/telemetry/telemetry/results/page_test_results_unittest.py

@@ -6,7 +6,6 @@ from telemetry.results import base_test_results_unittest
 
 from telemetry.page import page_set
 from telemetry.results import page_test_results
-from telemetry.value import failure
 
 class NonPrintingPageTestResults(
     page_test_results.PageTestResults):
@@ -29,8 +28,8 @@ class PageTestResultsTest(base_test_results_unittest.BaseTestResultsUnittest):
 
   def test_failures(self):
     results = NonPrintingPageTestResults()
-    results.AddValue(
-        failure.FailureValue(self.pages[0], self.CreateException()))
+    results.AddFailure(self.pages[0], self.CreateException())
     results.AddSuccess(self.pages[1])
-    self.assertEquals(results.pages_that_had_failures, [self.pages[0]])
+    self.assertEquals(results.pages_that_had_failures,
+                      set([self.pages[0]]))
     self.assertEquals(results.successes, [self.pages[1]])

tools/telemetry/telemetry/value/failure.py

-# 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.
-
-import sys
-import traceback
-
-from telemetry import value as value_module
-
-class FailureValue(value_module.Value):
-
-  def __init__(self, page, exc_info):
-    """A value representing a failure when running the page.
-
-    Args:
-      page: The page where this failure occurs.
-      exc_info: The exception info (sys.exc_info()) corresponding to
-          this failure.
-    """
-    exc_type = exc_info[0].__name__
-    super(FailureValue, self).__init__(page, exc_type, '', True)
-    self._exc_info = exc_info
-
-  @classmethod
-  def FromMessage(cls, page, message):
-    """Creates a failure value for a given string message.
-
-    Args:
-      page: The page where this failure occurs.
-      message: A string message describing the failure.
-    """
-    try:
-      raise Exception(message)
-    except Exception:
-      return FailureValue(page, sys.exc_info())
-
-  def __repr__(self):
-    if self.page:
-      page_name = self.page.url
-    else:
-      page_name = None
-    return 'FailureValue(%s, %s)' % (
-        page_name, GetStringFromExcInfo(self._exc_info))
-
-  @property
-  def exc_info(self):
-    return self._exc_info
-
-  def GetBuildbotDataType(self, output_context):
-    return None
-
-  def GetBuildbotValue(self):
-    return None
-
-  def GetBuildbotMeasurementAndTraceNameForPerPageResult(self):
-    return None
-
-  def GetRepresentativeNumber(self):
-    return None
-
-  def GetRepresentativeString(self):
-    return None
-
-  @classmethod
-  def GetJSONTypeName(cls):
-    return 'failure'
-
-  def AsDict(self):
-    d = super(FailureValue, self).AsDict()
-    d['value'] = GetStringFromExcInfo(self.exc_info)
-    return d
-
-  @classmethod
-  def MergeLikeValuesFromSamePage(cls, values):
-    assert False, 'Should not be called.'
-
-  @classmethod
-  def MergeLikeValuesFromDifferentPages(cls, values,
-                                        group_by_name_suffix=False):
-    assert False, 'Should not be called.'
-
-def GetStringFromExcInfo(exc_info):
-  return ''.join(traceback.format_exception(*exc_info))

tools/telemetry/telemetry/value/failure_unittest.py

-# 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.
-
-import os
-import sys
-import unittest
-
-from telemetry import value
-from telemetry.page import page_set
-from telemetry.value import failure
-
-class TestBase(unittest.TestCase):
-  def setUp(self):
-    self.page_set = page_set.PageSet(file_path=os.path.dirname(__file__))
-    self.page_set.AddPageWithDefaultRunNavigate("http://www.bar.com/")
-
-  @property
-  def pages(self):
-    return self.page_set.pages
-
-class ValueTest(TestBase):
-  def testName(self):
-    v0 = failure.FailureValue.FromMessage(self.pages[0], 'Failure')
-    self.assertEqual('Exception', v0.name)
-    try:
-      raise NotImplementedError()
-    except Exception:
-      v1 = failure.FailureValue(self.pages[0], sys.exc_info())
-    self.assertEqual('NotImplementedError', v1.name)
-
-  def testBuildbotAndRepresentativeValue(self):
-    v = failure.FailureValue.FromMessage(self.pages[0], 'Failure')
-    self.assertIsNone(v.GetBuildbotValue())
-    self.assertIsNone(v.GetBuildbotDataType(
-        value.COMPUTED_PER_PAGE_SUMMARY_OUTPUT_CONTEXT))
-    self.assertIsNone(v.GetBuildbotMeasurementAndTraceNameForPerPageResult())
-    self.assertIsNone(v.GetRepresentativeNumber())
-    self.assertIsNone(v.GetRepresentativeString())
-
-  def testAsDict(self):
-    v = failure.FailureValue.FromMessage(self.pages[0], 'Failure')
-    d = v.AsDictWithoutBaseClassEntries()
-    self.assertTrue(d['value'].find('Exception: Failure') > -1)

tools/telemetry/telemetry/value/merge_values.py

 # 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 telemetry.value import failure
-
 def MergeLikeValuesFromSamePage(all_values):
   """Merges values that measure the same thing on the same page.
 
@@ -111,12 +108,6 @@ def GroupStably(all_values, key_func):
   merge_groups = {}
   merge_groups_in_creation_order = []
   for value in all_values:
-    # TODO(chrishenry): This is temporary. When we figure out the
-    # right summarization strategy for page runs with failures, we
-    # should use that instead.
-    if isinstance(value, failure.FailureValue):
-      continue
-
     key = key_func(value)
     if key not in merge_groups:
       merge_groups[key] = []

tools/telemetry/telemetry/value/summary.py

@@ -4,7 +4,6 @@
 
 from collections import defaultdict
 
-from telemetry.value import failure
 from telemetry.value import merge_values
 
 class Summary(object):
@@ -59,9 +58,7 @@ class Summary(object):
     return self._interleaved_computed_per_page_values_and_summaries
 
   def _ComputePerPageValues(self, all_page_specific_values):
-    all_successful_page_values = [
-        v for v in all_page_specific_values if not isinstance(
-            v, failure.FailureValue)]
+    all_successful_page_values = all_page_specific_values
 
     # We will later need to determine how many values were originally created
     # for each value name, to apply a workaround meant to clean up the printf