Create classes_util API, change discover to return a list instead of a dict.

tools/telemetry/telemetry/record_wpr.py

 # Copyright 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 argparse
 import logging
 import sys
 
 from telemetry import benchmark
 from telemetry import story
-from telemetry.core import discover
 from telemetry.core import util
 from telemetry.internal.browser import browser_options
 from telemetry.internal.results import results_options
 from telemetry.internal import story_runner
 from telemetry.page import page_test
+from telemetry.util import classes_util
 from telemetry.util import wpr_modes
 
 
 class RecorderPageTest(page_test.PageTest):
   def __init__(self):
     super(RecorderPageTest, self).__init__()
     self.page_test = None
 
   def CustomizeBrowserOptions(self, options):
     if self.page_test:
@@ skipping 26 matching lines @@
   def ValidateAndMeasurePage(self, page, tab, results):
     if self.page_test:
       self.page_test.ValidateAndMeasurePage(page, tab, results)
 
   def RunNavigateSteps(self, page, tab):
     if self.page_test:
       self.page_test.RunNavigateSteps(page, tab)
     else:
       super(RecorderPageTest, self).RunNavigateSteps(page, tab)
 
-
-def _GetSubclasses(base_dir, cls):
-  """ Return all subclasses of |cls| in |base_dir|.
-  Args:
-    cls: a class
-  Returns:
-
-  """
-  return discover.DiscoverClasses(base_dir, base_dir, cls,
-                                  index_by_class_name=True)
-
-
 def _MaybeGetInstanceOfClass(target, base_dir, cls):
   if isinstance(target, cls):
     return target
-  classes = _GetSubclasses(base_dir, cls)
-  return classes[target]() if target in classes else None
-
+  return classes_util.MaybeGetInstanceOfClass(target, base_dir, base_dir, cls)
 
 def _PrintAllBenchmarks(base_dir, output_stream):
   # TODO: reuse the logic of finding supported benchmarks in benchmark_runner.py
   # so this only prints out benchmarks that are supported by the recording
   # platform.
-  classes = _GetSubclasses(base_dir, benchmark.Benchmark)
+  classes = classes_util.DiscoverClassesByClassName(
+      base_dir, base_dir, benchmark.Benchmark)
   output_stream.write('Available benchmarks\' names:\n\n')
   for k in classes:
     output_stream.write('%s\n' % k)
 
 
 def _PrintAllUserStories(base_dir, output_stream):
   output_stream.write('Available page sets\' names:\n\n')
   # TODO: actually print all stories once record_wpr support general
   # stories recording.
-  classes = _GetSubclasses(base_dir, story.StorySet)
+  classes = classes_util.DiscoverClassesByClassName(
+      base_dir, base_dir, story.StorySet)
   for k in classes:
     output_stream.write('%s\n' % k)
 
 
 class WprRecorder(object):
 
   def __init__(self, base_dir, target, args=None):
     self._record_page_test = RecorderPageTest()
     self._options = self._CreateOptions()
 
-    self._benchmark = _MaybeGetInstanceOfClass(target, base_dir,
-                                               benchmark.Benchmark)
+    self._benchmark = _MaybeGetInstanceOfClass(
+        target, base_dir, benchmark.Benchmark)
     self._parser = self._options.CreateParser(usage='See %prog --help')
     self._AddCommandLineArgs()
     self._ParseArgs(args)
     self._ProcessCommandLineArgs()
     if self._benchmark is not None:
       # This must be called after the command line args are added.
       self._record_page_test.page_test = self._benchmark.CreatePageTest(
           self.options)
 
     if self._options.page_set_base_dir:
@@ skipping 102 matching lines @@
     return 0
 
   # TODO(nednguyen): update WprRecorder so that it handles the difference
   # between recording a benchmark vs recording a story better based on
   # the distinction between args.benchmark & args.story
   wpr_recorder = WprRecorder(base_dir, target, extra_args)
   results = wpr_recorder.CreateResults()
   wpr_recorder.Record(results)
   wpr_recorder.HandleResults(results, args.upload)
   return min(255, len(results.failures))