[telemetry] Move Results options out of PageTest/Measurement into their own module.

tools/telemetry/telemetry/page/page_test.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.
 import logging
 
 from telemetry.core import util
-from telemetry.page import gtest_test_results
 from telemetry.page import test_expectations
-from telemetry.page import page_test_results
 from telemetry.page.actions import all_page_actions
 from telemetry.page.actions import navigate
 from telemetry.page.actions import page_action
 
+
 def _GetActionFromData(action_data):
   action_name = action_data['action']
   action = all_page_actions.FindClassWithName(action_name)
   if not action:
     logging.critical('Could not find an action named %s.', action_name)
     logging.critical('Check the page set for a typo and check the error '
                      'log for possible Python loading/compilation errors.')
     raise Exception('Action "%s" not found.' % action_name)
   return action(action_data)
 
+
 def GetCompoundActionFromPage(page, action_name):
   if not action_name:
     return []
 
   action_data_list = getattr(page, action_name)
   if not isinstance(action_data_list, list):
     action_data_list = [action_data_list]
 
   action_list = []
   for subaction_data in action_data_list:
     subaction_name = subaction_data['action']
     if hasattr(page, subaction_name):
       subaction = GetCompoundActionFromPage(page, subaction_name)
     else:
       subaction = [_GetActionFromData(subaction_data)]
     action_list += subaction * subaction_data.get('repeat', 1)
   return action_list
 
+
 class Failure(Exception):
   """Exception that can be thrown from PageMeasurement to indicate an
   undesired but designed-for problem."""
   pass
 
+
 class PageTest(object):
   """A class styled on unittest.TestCase for creating page-specific tests."""
 
   def __init__(self,
                test_method_name,
                action_name_to_run='',
                needs_browser_restart_after_each_run=False,
                discard_first_result=False,
                clear_cache_before_each_run=False):
     self.options = None
@@ skipping 103 matching lines @@
   def CreatePageSet(self, args, options):  # pylint: disable=W0613
     """Override to make this test generate its own page set instead of
     allowing arbitrary page sets entered from the command-line."""
     return None
 
   def CreateExpectations(self, page_set):  # pylint: disable=W0613
     """Override to make this test generate its own expectations instead of
     any that may have been defined in the page set."""
     return test_expectations.TestExpectations()
 
-  def AddOutputOptions(self, parser):
-    parser.add_option('--output-format',
-                      default=self.output_format_choices[0],
-                      choices=self.output_format_choices,
-                      help='Output format. Defaults to "%%default". '
-                      'Can be %s.' % ', '.join(self.output_format_choices))
-
-  @property
-  def output_format_choices(self):
-    """Allowed output formats. The default is the first item in the list."""
-    return ['gtest', 'none']
-
-  def PrepareResults(self, options):
-    if not hasattr(options, 'output_format'):
-      options.output_format = self.output_format_choices[0]
-
-    if options.output_format == 'gtest':
-      return gtest_test_results.GTestTestResults()
-    elif options.output_format == 'none':
-      return page_test_results.PageTestResults()
-    else:
-      # Should never be reached. The parser enforces the choices.
-      raise Exception('Invalid --output-format "%s". Valid choices are: %s'
-                      % (options.output_format,
-                         ', '.join(self.output_format_choices)))
-
   def Run(self, options, page, tab, results):
     self.options = options
     compound_action = GetCompoundActionFromPage(page, self._action_name_to_run)
     self._RunCompoundAction(page, tab, compound_action)
     try:
       self._test_method(page, tab, results)
     finally:
       self.options = None
 
   def _RunCompoundAction(self, page, tab, actions, run_setup_methods=True):
@@ skipping 36 matching lines @@
     else:
       # TODO(edmundyan): Make a default navigate_steps action on the page object
       # once we can deprecate page.WaitToLoad()
       i = navigate.NavigateAction()
       i.RunAction(page, tab, None)
       page.WaitToLoad(tab, 60)
 
   @property
   def action_name_to_run(self):
     return self._action_name_to_run