Revert of [telemetry] Refactor run_tests to remove old cruft.

tools/telemetry/telemetry/unittest/run_tests.py

Index: tools/telemetry/telemetry/unittest/run_tests.py
diff --git a/tools/telemetry/telemetry/unittest/run_tests.py b/tools/telemetry/telemetry/unittest/run_tests.py
index 727bfc84421f1eb05e25997977c93fc3622fbc32..2605f342b2b5530cdfa9b90d0fece005cedfcdf2 100644
--- a/tools/telemetry/telemetry/unittest/run_tests.py
+++ b/tools/telemetry/telemetry/unittest/run_tests.py
@@ -3,86 +3,73 @@
 # found in the LICENSE file.
 
 import logging
-import sys
 import unittest
 
 from telemetry import decorators
-from telemetry.core import browser_finder
 from telemetry.core import browser_options
-from telemetry.core import command_line
 from telemetry.core import discover
 from telemetry.core import util
-from telemetry.unittest import gtest_unittest_results
+from telemetry.unittest import gtest_testrunner
 from telemetry.unittest import options_for_unittests
-
-
-class Environment(object):
-  def __init__(self, top_level_dir, test_dirs):
-    self._top_level_dir = top_level_dir
-    self._test_dirs = tuple(test_dirs)
-
-  @property
-  def top_level_dir(self):
-    return self._top_level_dir
-
-  @property
-  def test_dirs(self):
-    return self._test_dirs
 
 
 def Discover(start_dir, top_level_dir=None, pattern='test*.py'):
   loader = unittest.defaultTestLoader
-  loader.suiteClass = gtest_unittest_results.GTestTestSuite
+  loader.suiteClass = gtest_testrunner.GTestTestSuite
+  subsuites = []
 
-  test_suites = []
   modules = discover.DiscoverModules(start_dir, top_level_dir, pattern)
   for module in modules:
     if hasattr(module, 'suite'):
-      suite = module.suite()
+      new_suite = module.suite()
     else:
-      suite = loader.loadTestsFromModule(module)
-    if suite.countTestCases():
-      test_suites.append(suite)
-  return test_suites
+      new_suite = loader.loadTestsFromModule(module)
+    if new_suite.countTestCases():
+      subsuites.append(new_suite)
+  return gtest_testrunner.GTestTestSuite(subsuites)
 
 
 def FilterSuite(suite, predicate):
   new_suite = suite.__class__()
-  for test in suite:
-    if isinstance(test, unittest.TestSuite):
-      subsuite = FilterSuite(test, predicate)
-      if subsuite.countTestCases():
-        new_suite.addTest(subsuite)
-    else:
-      assert isinstance(test, unittest.TestCase)
-      if predicate(test):
-        new_suite.addTest(test)
+  for x in suite:
+    if isinstance(x, unittest.TestSuite):
+      subsuite = FilterSuite(x, predicate)
+      if subsuite.countTestCases() == 0:
+        continue
+
+      new_suite.addTest(subsuite)
+      continue
+
+    assert isinstance(x, unittest.TestCase)
+    if predicate(x):
+      new_suite.addTest(x)
 
   return new_suite
 
 
-def DiscoverTests(search_dirs, top_level_dir, possible_browser,
-                  selected_tests=None, run_disabled_tests=False):
+def DiscoverAndRunTests(dir_name, args, top_level_dir, possible_browser,
+                        default_options, runner):
+  if not runner:
+    runner = gtest_testrunner.GTestTestRunner(print_result_after_run=True)
+  suite = Discover(dir_name, top_level_dir, '*_unittest.py')
   def IsTestSelected(test):
-    if selected_tests:
+    if len(args) != 0:
       found = False
-      for name in selected_tests:
+      for name in args:
         if name in test.id():
           found = True
       if not found:
         return False
-    if run_disabled_tests:
+    if default_options.run_disabled_tests:
       return True
     # pylint: disable=W0212
     if not hasattr(test, '_testMethodName'):
       return True
     method = getattr(test, test._testMethodName)
     return decorators.IsEnabled(method, possible_browser)
-
-  wrapper_suite = gtest_unittest_results.GTestTestSuite()
-  for search_dir in search_dirs:
-    wrapper_suite.addTests(Discover(search_dir, top_level_dir, '*_unittest.py'))
-  return FilterSuite(wrapper_suite, IsTestSelected)
+  filtered_suite = FilterSuite(suite, IsTestSelected)
+  test_result = runner.run(filtered_suite)
+  return test_result
 
 
 def RestoreLoggingLevel(func):
@@ -100,61 +87,53 @@
   return _LoggingRestoreWrapper
 
 
-environment = None
+@RestoreLoggingLevel
+def Main(args, start_dir, top_level_dir, runner=None):
+  """Unit test suite that collects all test cases for telemetry."""
+  # Add unittest_data to the path so we can import packages from it.
+  util.AddDirToPythonPath(util.GetUnittestDataDir())
 
+  default_options = browser_options.BrowserFinderOptions()
+  default_options.browser_type = 'any'
 
-class RunTestsCommand(command_line.OptparseCommand):
-  """Run unit tests"""
+  parser = default_options.CreateParser('run_tests [options] [test names]')
+  parser.add_option('--repeat-count', dest='run_test_repeat_count',
+                    type='int', default=1,
+                    help='Repeats each a provided number of times.')
+  parser.add_option('-d', '--also-run-disabled-tests',
+                    dest='run_disabled_tests',
+                    action='store_true', default=False,
+                    help='Ignore @Disabled and @Enabled restrictions.')
 
-  usage = '[test_name ...] [<options>]'
+  _, args = parser.parse_args(args)
 
-  @classmethod
-  def CreateParser(cls):
-    options = browser_options.BrowserFinderOptions()
-    options.browser_type = 'any'
-    parser = options.CreateParser('%%prog %s' % cls.usage)
-    return parser
+  if default_options.verbosity == 0:
+    logging.getLogger().setLevel(logging.WARN)
 
-  @classmethod
-  def AddCommandLineArgs(cls, parser):
-    parser.add_option('--repeat-count', dest='run_test_repeat_count',
-                      type='int', default=1,
-                      help='Repeats each a provided number of times.')
-    parser.add_option('-d', '--also-run-disabled-tests',
-                      dest='run_disabled_tests',
-                      action='store_true', default=False,
-                      help='Ignore @Disabled and @Enabled restrictions.')
+  from telemetry.core import browser_finder
+  try:
+    browser_to_create = browser_finder.FindBrowser(default_options)
+  except browser_finder.BrowserFinderException, ex:
+    logging.error(str(ex))
+    return 1
 
-  @classmethod
-  def ProcessCommandLineArgs(cls, parser, args):
-    if args.verbosity == 0:
-      logging.getLogger().setLevel(logging.WARN)
+  if browser_to_create == None:
+    logging.error('No browser found of type %s. Cannot run tests.',
+                  default_options.browser_type)
+    logging.error('Re-run with --browser=list to see available browser types.')
+    return 1
 
-    try:
-      possible_browser = browser_finder.FindBrowser(args)
-    except browser_finder.BrowserFinderException, ex:
-      parser.error(ex)
+  options_for_unittests.Set(default_options,
+                            browser_to_create.browser_type)
+  try:
+    success = True
+    for _ in xrange(default_options.run_test_repeat_count):
+      success = success and DiscoverAndRunTests(
+          start_dir, args, top_level_dir, browser_to_create, default_options,
+          runner)
+    if success:
+      return 0
+  finally:
+    options_for_unittests.Set(None, None)
 
-    if not possible_browser:
-      parser.error('No browser found of type %s. Cannot run tests.\n'
-                   'Re-run with --browser=list to see '
-                   'available browser types.' % args.browser_type)
-
-    cls.test_suite = DiscoverTests(
-        environment.test_dirs, environment.top_level_dir, possible_browser,
-        args.positional_args, args.run_disabled_tests)
-
-  @RestoreLoggingLevel
-  def Run(self, args):
-    util.AddDirToPythonPath(util.GetUnittestDataDir())
-
-    result = gtest_unittest_results.GTestUnittestResults(sys.stdout)
-    try:
-      options_for_unittests.Set(args)
-      for _ in xrange(args.run_test_repeat_count):
-        self.test_suite(result)
-    finally:
-      options_for_unittests.Set(None)
-
-    result.PrintSummary()
-    return len(result.failures) + len(result.errors)
+  return 1