Revert of [Telemetry] Migrate browser_test_runner to use typ as the test runner

telemetry/telemetry/testing/serially_executed_browser_test_case.py

 # Copyright 2016 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 inspect
 import re
 import unittest
 
 from py_utils import cloud_storage
 from telemetry.internal.browser import browser_finder
-from telemetry.testing import browser_test_context
+from telemetry.testing import options_for_unittests
 from telemetry.util import wpr_modes
 
 
 class SeriallyExecutedBrowserTestCase(unittest.TestCase):
   def __init__(self, methodName):
     super(SeriallyExecutedBrowserTestCase, self).__init__(methodName)
     self._private_methodname = methodName
 
   def shortName(self):
     """Returns the method name this test runs, without the package prefix."""
     return self._private_methodname
 
   @classmethod
   def Name(cls):
     return cls.__name__
 
   @classmethod
   def AddCommandlineArgs(cls, parser):
     pass
 
   @classmethod
-  def SetUpProcess(cls):
-    """ Set up testing logic before running the test case.
-    This is guaranteed to be called only once for all the tests before the test
-    suite runs.
-    """
-    cls._finder_options = browser_test_context.GetCopy().finder_options
+  def setUpClass(cls):
+    cls._finder_options = options_for_unittests.GetCopy()
     cls.platform = None
     cls.browser = None
     cls._browser_to_create = None
     cls._browser_options = None
 
   @classmethod
   def SetBrowserOptions(cls, browser_options):
     """Sets the browser option for the browser to create.
 
     Args:
@@ skipping 40 matching lines @@
 
     cls.browser = cls._browser_to_create.Create(cls._browser_options)
 
   @classmethod
   def StopBrowser(cls):
     assert cls.browser, 'Browser is not started'
     cls.browser.Close()
     cls.browser = None
 
   @classmethod
-  def TearDownProcess(cls):
-    """ Tear down the testing logic after running the test cases.
-    This is guaranteed to be called only once for all the tests after the test
-    suite finishes running.
-    """
-
+  def tearDownClass(cls):
     if cls.platform:
       cls.platform.StopAllLocalServers()
       cls.platform.network_controller.Close()
     if cls.browser:
       cls.StopBrowser()
 
   @classmethod
   def SetStaticServerDirs(cls, dirs_path):
     assert cls.platform
     assert isinstance(dirs_path, list)
@@ skipping 29 matching lines @@
   #################################################################
 
   Args:
     module: the module which contains test cases classes.
 
   Returns:
     an instance of unittest.TestSuite, which contains all the tests & generated
     test cases to be run.
   """
   suite = unittest.TestSuite()
-  test_context = browser_test_context.GetCopy()
-  if not test_context:
+  finder_options = options_for_unittests.GetCopy()
+  if not hasattr(finder_options, 'browser_test_runner_running'):
     return suite
   for _, obj in inspect.getmembers(module):
     if (inspect.isclass(obj) and
         issubclass(obj, SeriallyExecutedBrowserTestCase)):
-      # We bail out early if this class doesn't match the targeted
-      # test_class in test_context to avoid calling GenerateTestCases
-      # for tests that we don't intend to run. This is to avoid possible errors
-      # in GenerateTestCases as the test class may define custom options in
-      # the finder_options object, and hence would raise error if they can't
-      # find their custom options in finder_options object.
-      if test_context.test_class != obj:
-        continue
       for test in GenerateTestCases(
-          test_class=obj, finder_options=test_context.finder_options):
-        if test.id() in test_context.test_case_ids_to_run:
-          suite.addTest(test)
+          test_class=obj, finder_options=finder_options):
+        suite.addTest(test)
   return suite
 
 
 def _GenerateTestMethod(based_method, args):
   return lambda self: based_method(self, *args)
 
 
 _TEST_GENERATOR_PREFIX = 'GenerateTestCases_'
 _INVALID_TEST_NAME_RE = re.compile(r'[^a-zA-Z0-9_]')
 
@@ skipping 19 matching lines @@
       assert hasattr(test_class, based_method_name), (
           '%s is specified but based method %s does not exist' %
           (name, based_method_name))
       based_method = getattr(test_class, based_method_name)
       for generated_test_name, args in method(finder_options):
         _ValidateTestMethodname(generated_test_name)
         setattr(test_class, generated_test_name, _GenerateTestMethod(
             based_method, args))
         test_cases.append(test_class(generated_test_name))
   return test_cases