TimelineBasedMeasurement(object) instead of TimelineBasedMeasurement(page_test.PageTest)

tools/telemetry/telemetry/benchmark.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 logging
 import optparse
 import os
 import shutil
 import sys
 import zipfile
 
 from telemetry import decorators
 from telemetry import page
 from telemetry.core import browser_finder
 from telemetry.core import command_line
 from telemetry.core import util
 from telemetry.user_story import user_story_runner
 from telemetry.page import page_set
 from telemetry.page import page_test
 from telemetry.page import test_expectations
 from telemetry.results import results_options
 from telemetry.util import cloud_storage
 from telemetry.util import exception_formatter
+from telemetry.web_perf import timeline_based_measurement
 
 Disabled = decorators.Disabled
 Enabled = decorators.Enabled
 
 
 class InvalidOptionsError(Exception):
   """Raised for invalid benchmark options."""
   pass
 
 
 class BenchmarkMetadata(object):
   def __init__(self, name, description=''):
     self._name = name
     self._description = description
 
   @property
   def name(self):
     return self._name
 
   @property
   def description(self):
       return self._description
 
 
 class Benchmark(command_line.Command):
   """Base class for a Telemetry benchmark.
 
-  A test packages a PageTest and a PageSet together.
+  A benchmark packages a measurement and a PageSet together.
+  Benchmarks default to using TBM unless you override the value of
+  Benchmark.test, or override the CreatePageTest method.
+
+  New benchmarks should override CreateUserStorySet.
   """
   options = {}
+  test = timeline_based_measurement.TimelineBasedMeasurement
 
   def __init__(self, max_failures=None):
     """Creates a new Benchmark.
 
     Args:
       max_failures: The number of user story run's failures before bailing
           from executing subsequent page runs. If None, we never bail.
     """
     self._max_failures = max_failures
+    self._has_original_tbm_options = (
+        self.CreateTimelineBasedMeasurementOptions.__func__ ==
+        Benchmark.CreateTimelineBasedMeasurementOptions.__func__)
+    has_original_create_page_test = (
+        self.CreatePageTest.__func__ == Benchmark.CreatePageTest.__func__)
+    assert self._has_original_tbm_options or has_original_create_page_test, (
+        'Cannot override both CreatePageTest and '
+        'CreateTimelineBasedMeasurementOptions.')
 
   @classmethod
   def Name(cls):
     name = cls.__module__.split('.')[-1]
     if hasattr(cls, 'tag'):
       name += '.' + cls.tag
     if hasattr(cls, 'page_set'):
       name += '.' + cls.page_set.Name()
     return name
 
@@ skipping 127 matching lines @@
         if os.path.exists(extracted_profile_dir_path):
           shutil.rmtree(extracted_profile_dir_path)
         logging.error("Error extracting profile directory zip file: %s", e)
         sys.exit(-1)
 
     # Run with freshly extracted profile directory.
     logging.info("Using profile archive directory: %s",
         extracted_profile_dir_path)
     options.browser_options.profile_dir = extracted_profile_dir_path
 
-  def CreatePageTest(self, options):  # pylint: disable=W0613
-    """Get the PageTest for this Benchmark.
+  def CreateTimelineBasedMeasurementOptions(self):
+    """Return the TimelineBasedMeasurementOptions for this Benchmark.
 
-    By default, it will create a page test from the test's test attribute.
-    Override to generate a custom page test.
+    Override this method to configure a TimelineBasedMeasurement benchmark.
+    Otherwise, override CreatePageTest for PageTest tests. Do not override
+    both methods.
     """
-    if not hasattr(self, 'test'):
-      raise NotImplementedError('This test has no "test" attribute.')
-    if not issubclass(self.test, page_test.PageTest):
-      raise TypeError('"%s" is not a PageTest.' % self.test.__name__)
-    return self.test()
+    return timeline_based_measurement.Options()
 
-  def CreatePageSet(self, options):  # pylint: disable=W0613
+  def CreatePageTest(self, options):  # pylint: disable=unused-argument
+    """Return the PageTest for this Benchmark.
+
+    Override this method for PageTest tests.
+    Override, override CreateTimelineBasedMeasurementOptions to configure
+    TimelineBasedMeasurement tests. Do not override both methods.
+
+    Args:
+      options: a browser_options.BrowserFinderOptions instance
+    Returns:
+      |test()| if |test| is a PageTest class.
+      Otherwise, a TimelineBasedMeasurement instance.
+    """
+    is_page_test = issubclass(self.test, page_test.PageTest)
+    is_tbm = self.test == timeline_based_measurement.TimelineBasedMeasurement
+    if not is_page_test and not is_tbm:
+      raise TypeError('"%s" is not a PageTest or a TimelineBasedMeasurement.' %
+                      self.test.__name__)
+    if is_page_test:
+      assert self._has_original_tbm_options, (
+          'Cannot override CreateTimelineBasedMeasurementOptions '
+          'with a PageTest.')
+      return self.test()  # pylint: disable=no-value-for-parameter
+    return timeline_based_measurement.TimelineBasedMeasurement(
+        self.CreateTimelineBasedMeasurementOptions())
+
+  def CreatePageSet(self, options):  # pylint: disable=unused-argument
     """Get the page set this test will run on.
 
     By default, it will create a page set from the this test's page_set
     attribute. Override to generate a custom page set.
     """
     if not hasattr(self, 'page_set'):
       raise NotImplementedError('This test has no "page_set" attribute.')
     if not issubclass(self.page_set, page_set.PageSet):
       raise TypeError('"%s" is not a PageSet.' % self.page_set.__name__)
     return self.page_set()
@@ skipping 10 matching lines @@
     """
     return test_expectations.TestExpectations()
 
 
 def AddCommandLineArgs(parser):
   user_story_runner.AddCommandLineArgs(parser)
 
 
 def ProcessCommandLineArgs(parser, args):
   user_story_runner.ProcessCommandLineArgs(parser, args)