diff --git a/content/test/gpu/gpu_tests/gpu_test_base_unittest.py b/content/test/gpu/gpu_tests/gpu_test_base_unittest.py
index 969202527980ef..f1ddf36065f642 100644
--- a/content/test/gpu/gpu_tests/gpu_test_base_unittest.py
+++ b/content/test/gpu/gpu_tests/gpu_test_base_unittest.py
@@ -5,10 +5,10 @@
 import unittest
 
 from telemetry import benchmark
-from telemetry.core import discover
 from telemetry.core import util
 from telemetry.story import story_set as story_set_module
 from telemetry.testing import fakes
+from telemetry.util import classes_util
 
 util.AddDirToPythonPath(util.GetTelemetryDir(), 'third_party', 'mock')
 import mock # pylint: disable=import-error
@@ -23,10 +23,8 @@ def _GetGpuDir(*subdirs):
 
 class NoOverridesTest(unittest.TestCase):
   def testValidatorBase(self):
-    all_validators = discover.DiscoverClasses(
-      _GetGpuDir('gpu_tests'), _GetGpuDir(),
-      gpu_test_base.ValidatorBase,
-      index_by_class_name=True).values()
+    all_validators = classes_util.DiscoverClasses(
+      _GetGpuDir('gpu_tests'), _GetGpuDir(), gpu_test_base.ValidatorBase)
     self.assertGreater(len(all_validators), 0)
     for validator in all_validators:
       self.assertEquals(gpu_test_base.ValidatorBase.ValidateAndMeasurePage,
@@ -35,10 +33,8 @@ def testValidatorBase(self):
                         % validator.__name__)
 
   def testPageBase(self):
-    all_pages = discover.DiscoverClasses(
-      _GetGpuDir(), _GetGpuDir(),
-      gpu_test_base.PageBase,
-      index_by_class_name=True).values()
+    all_pages = classes_util.DiscoverClasses(
+      _GetGpuDir(), _GetGpuDir(), gpu_test_base.PageBase)
     self.assertGreater(len(all_pages), 0)
     for page in all_pages:
       self.assertEquals(gpu_test_base.PageBase.RunNavigateSteps,
diff --git a/content/test/gpu/page_sets/__init__.py b/content/test/gpu/page_sets/__init__.py
index ccb12f67bfc8f3..7d6dd796b8ec9d 100644
--- a/content/test/gpu/page_sets/__init__.py
+++ b/content/test/gpu/page_sets/__init__.py
@@ -4,14 +4,13 @@
 import os
 import sys
 
-from telemetry.core import discover
 from telemetry.story import story_set
+from telemetry.util import classes_util
 
 
 # Import all submodules' StorySet classes.
 start_dir = os.path.dirname(os.path.abspath(__file__))
 top_level_dir = os.path.dirname(start_dir)
 base_class = story_set.StorySet
-for cls in discover.DiscoverClasses(
-    start_dir, top_level_dir, base_class).values():
+for cls in classes_util.DiscoverClasses(start_dir, top_level_dir, base_class):
   setattr(sys.modules[__name__], cls.__name__, cls)
diff --git a/tools/chrome_proxy/integration_tests/chrome_proxy_pagesets/__init__.py b/tools/chrome_proxy/integration_tests/chrome_proxy_pagesets/__init__.py
index 799c2462114f87..c5699ad3ace02b 100644
--- a/tools/chrome_proxy/integration_tests/chrome_proxy_pagesets/__init__.py
+++ b/tools/chrome_proxy/integration_tests/chrome_proxy_pagesets/__init__.py
@@ -6,8 +6,9 @@
 import os
 import sys
 
-from telemetry.core import discover
 from telemetry import story
+from telemetry.util import classes_util
+
 import video
 
 
@@ -15,8 +16,7 @@
 start_dir = os.path.dirname(os.path.abspath(__file__))
 top_level_dir = os.path.abspath(os.path.join(start_dir, os.pardir, os.pardir))
 base_class = story.StorySet
-for cls in discover.DiscoverClasses(
-    start_dir, top_level_dir, base_class).values():
+for cls in classes_util.DiscoverClasses(start_dir, top_level_dir, base_class):
   setattr(sys.modules[__name__], cls.__name__, cls)
 
 # DiscoverClasses makes the assumption that there is exactly one matching
diff --git a/tools/chrome_proxy/live_tests/pagesets/__init__.py b/tools/chrome_proxy/live_tests/pagesets/__init__.py
index 45ce4af9df80c5..a67d12d383c435 100644
--- a/tools/chrome_proxy/live_tests/pagesets/__init__.py
+++ b/tools/chrome_proxy/live_tests/pagesets/__init__.py
@@ -6,15 +6,14 @@
 import os
 import sys
 
-from telemetry.core import discover
 from telemetry import story
+from telemetry.util import classes_util
 
 
 # Import all submodules' StorySet classes.
 start_dir = os.path.dirname(os.path.abspath(__file__))
 top_level_dir = os.path.abspath(os.path.join(start_dir, os.pardir, os.pardir))
 base_class = story.StorySet
-for cls in discover.DiscoverClasses(
-    start_dir, top_level_dir, base_class).values():
+for cls in classes_util.DiscoverClasses(start_dir, top_level_dir, base_class):
   setattr(sys.modules[__name__], cls.__name__, cls)
 
diff --git a/tools/perf/benchmarks/benchmark_smoke_unittest.py b/tools/perf/benchmarks/benchmark_smoke_unittest.py
index 69ffa268fbfaf8..b8ccb0cbb12270 100644
--- a/tools/perf/benchmarks/benchmark_smoke_unittest.py
+++ b/tools/perf/benchmarks/benchmark_smoke_unittest.py
@@ -104,11 +104,11 @@ def load_tests(loader, standard_tests, pattern):
   benchmarks_dir = os.path.dirname(__file__)
   top_level_dir = os.path.dirname(benchmarks_dir)
 
-  # Using the default of |index_by_class_name=False| means that if a module
-  # has multiple benchmarks, only the last one is returned.
+  # Using the default of |one_class_per_module=True| means that if a module
+  # has multiple benchmarks, only the first one is returned.
   all_benchmarks = discover.DiscoverClasses(
       benchmarks_dir, top_level_dir, benchmark_module.Benchmark,
-      index_by_class_name=False).values()
+      one_class_per_module=True)
   for benchmark in all_benchmarks:
     if sys.modules[benchmark.__module__] in _BLACK_LIST_TEST_MODULES:
       continue
diff --git a/tools/perf/benchmarks/benchmark_unittest.py b/tools/perf/benchmarks/benchmark_unittest.py
index 9fe848d1a1857b..d5d039c547f41a 100644
--- a/tools/perf/benchmarks/benchmark_unittest.py
+++ b/tools/perf/benchmarks/benchmark_unittest.py
@@ -11,9 +11,9 @@
 from core import perf_benchmark
 
 from telemetry import benchmark as benchmark_module
-from telemetry.core import discover
 from telemetry.internal.browser import browser_options
 from telemetry.testing import progress_reporter
+from telemetry.util import classes_util
 
 
 def _GetPerfDir(*subdirs):
@@ -22,9 +22,8 @@ def _GetPerfDir(*subdirs):
 
 
 def _GetAllPerfBenchmarks():
-  return discover.DiscoverClasses(
-      _GetPerfDir('benchmarks'), _GetPerfDir(), benchmark_module.Benchmark,
-      index_by_class_name=True).values()
+  return classes_util.DiscoverClasses(
+      _GetPerfDir('benchmarks'), _GetPerfDir(), benchmark_module.Benchmark)
 
 def _BenchmarkOptionsTestGenerator(benchmark):
   def testBenchmarkOptions(self):  # pylint: disable=W0613
diff --git a/tools/perf/benchmarks/skpicture_printer.py b/tools/perf/benchmarks/skpicture_printer.py
index 0247320f3135fc..2ed7b5a5de53c7 100644
--- a/tools/perf/benchmarks/skpicture_printer.py
+++ b/tools/perf/benchmarks/skpicture_printer.py
@@ -5,15 +5,15 @@
 from core import perf_benchmark
 
 from telemetry import benchmark
-from telemetry.core import discover
 from telemetry import story
+from telemetry.util import classes_util
 
 from measurements import skpicture_printer
 
 
 def _MatchPageSetName(story_set_name, story_set_base_dir):
-  story_sets = discover.DiscoverClasses(story_set_base_dir, story_set_base_dir,
-                                        story.StorySet).values()
+  story_sets = classes_util.DiscoverClasses(
+      story_set_base_dir, story_set_base_dir, story.StorySet)
   for s in story_sets:
     if story_set_name == s.Name():
       return s
diff --git a/tools/perf/measurements/measurement_smoke_test.py b/tools/perf/measurements/measurement_smoke_test.py
index bedd0ba05582bb..a8c8477844b399 100644
--- a/tools/perf/measurements/measurement_smoke_test.py
+++ b/tools/perf/measurements/measurement_smoke_test.py
@@ -8,10 +8,10 @@
 import unittest
 
 from telemetry import benchmark as benchmark_module
-from telemetry.core import discover
 from telemetry.internal.browser import browser_options
 from telemetry.page import page_test
 from telemetry.testing import options_for_unittests
+from telemetry.util import classes_util
 from telemetry.web_perf import timeline_based_measurement
 
 
@@ -23,14 +23,14 @@ def _GetAllPossiblePageTestInstances():
 
   # Get all page test instances from measurement classes that are directly
   # constructable
-  all_measurement_classes = discover.DiscoverClasses(
+  all_measurement_classes = classes_util.DiscoverClasses(
       measurements_dir, top_level_dir, page_test.PageTest,
-      index_by_class_name=True, directly_constructable=True).values()
+      directly_constructable=True)
   for measurement_class in all_measurement_classes:
     page_test_instances.append(measurement_class())
 
-  all_benchmarks_classes = discover.DiscoverClasses(
-      benchmarks_dir, top_level_dir, benchmark_module.Benchmark).values()
+  all_benchmarks_classes = classes_util.DiscoverClasses(
+      benchmarks_dir, top_level_dir, benchmark_module.Benchmark)
 
   # Get all page test instances from defined benchmarks.
   # Note: since this depends on the command line options, there is no guaranteed
diff --git a/tools/perf/page_sets/__init__.py b/tools/perf/page_sets/__init__.py
index 65daf2f00485ef..d585f3271d79f6 100644
--- a/tools/perf/page_sets/__init__.py
+++ b/tools/perf/page_sets/__init__.py
@@ -6,14 +6,14 @@
 import os
 import sys
 
-from telemetry.core import discover
 from telemetry import story
+from telemetry.util import classes_util
 
 
 # Import all submodules' PageSet classes.
 start_dir = os.path.dirname(os.path.abspath(__file__))
 top_level_dir = os.path.dirname(start_dir)
 base_class = story.StorySet
-for cls in discover.DiscoverClasses(
-    start_dir, top_level_dir, base_class).values():
+for cls in classes_util.DiscoverClasses(
+    start_dir, top_level_dir, base_class):
   setattr(sys.modules[__name__], cls.__name__, cls)
diff --git a/tools/perf/profile_creators/profile_generator.py b/tools/perf/profile_creators/profile_generator.py
index 4c52665525fd13..dc683828d711e0 100644
--- a/tools/perf/profile_creators/profile_generator.py
+++ b/tools/perf/profile_creators/profile_generator.py
@@ -13,11 +13,11 @@
 import tempfile
 
 from profile_creators import profile_extender
-from telemetry.core import discover
 from telemetry.core import util
 from telemetry.internal.browser import browser_finder
 from telemetry.internal.browser import browser_options
 from telemetry.internal import story_runner
+from telemetry.util import classes_util
 
 
 def _DiscoverProfileExtenderClasses():
@@ -25,7 +25,7 @@ def _DiscoverProfileExtenderClasses():
       os.pardir, 'perf', 'profile_creators'))
   base_dir = os.path.abspath(os.path.join(profile_extenders_dir, os.pardir))
 
-  profile_extenders_unfiltered = discover.DiscoverClasses(
+  profile_extenders_unfiltered = classes_util.DiscoverClassesByClassName(
       profile_extenders_dir, base_dir, profile_extender.ProfileExtender)
 
   # Remove 'extender' suffix from keys.
diff --git a/tools/telemetry/telemetry/benchmark_runner.py b/tools/telemetry/telemetry/benchmark_runner.py
index eecb9458d71167..78253600c17f2c 100644
--- a/tools/telemetry/telemetry/benchmark_runner.py
+++ b/tools/telemetry/telemetry/benchmark_runner.py
@@ -14,11 +14,11 @@
 import sys
 
 from telemetry import benchmark
-from telemetry.core import discover
 from telemetry import decorators
 from telemetry.internal.browser import browser_finder
 from telemetry.internal.browser import browser_options
 from telemetry.internal.util import command_line
+from telemetry.util import classes_util
 
 
 def PrintBenchmarkList(benchmarks, possible_browser, output_pipe=sys.stdout):
@@ -264,10 +264,9 @@ def _MatchingCommands(string):
 def _Benchmarks(environment):
   benchmarks = []
   for search_dir in environment.benchmark_dirs:
-    benchmarks += discover.DiscoverClasses(search_dir,
+    benchmarks += classes_util.DiscoverClasses(search_dir,
                                            environment.top_level_dir,
-                                           benchmark.Benchmark,
-                                           index_by_class_name=True).values()
+                                           benchmark.Benchmark)
   return benchmarks
 
 def _MatchBenchmarkName(input_benchmark_name, environment, exact_matches=True):
diff --git a/tools/telemetry/telemetry/core/discover.py b/tools/telemetry/telemetry/core/discover.py
index 546aa637232789..53393200acea97 100644
--- a/tools/telemetry/telemetry/core/discover.py
+++ b/tools/telemetry/telemetry/core/discover.py
@@ -7,12 +7,9 @@
 import os
 import re
 
-from telemetry import decorators
-from telemetry.internal.util import camel_case
 from telemetry.internal.util import classes as classes_module
 
 
-@decorators.Cache
 def DiscoverModules(start_dir, top_level_dir, pattern='*'):
   """Discover all modules in |start_dir| which match |pattern|.
 
@@ -49,12 +46,8 @@ def DiscoverModules(start_dir, top_level_dir, pattern='*'):
       modules.append(module)
   return modules
 
-
-# TODO(dtu): Normalize all discoverable classes to have corresponding module
-# and class names, then always index by class name.
-@decorators.Cache
 def DiscoverClasses(start_dir, top_level_dir, base_class, pattern='*',
-                    index_by_class_name=True, directly_constructable=False):
+                    one_class_per_module=False, directly_constructable=False):
   """Discover all classes in |start_dir| which subclass |base_class|.
 
   Base classes that contain subclasses are ignored by default.
@@ -64,24 +57,21 @@ def DiscoverClasses(start_dir, top_level_dir, base_class, pattern='*',
     top_level_dir: The top level of the package, for importing.
     base_class: The base class to search for.
     pattern: Unix shell-style pattern for filtering the filenames to import.
-    index_by_class_name: If True, use class name converted to
-        lowercase_with_underscores instead of module name in return dict keys.
+    one_class_per_module: If True, will only include the first class found in
+                each module.
     directly_constructable: If True, will only return classes that can be
         constructed without arguments
 
-  Returns:
-    dict of {module_name: class} or {underscored_class_name: class}
+  Returns: A list of classes.
   """
   modules = DiscoverModules(start_dir, top_level_dir, pattern)
-  classes = {}
+  classes = []
   for module in modules:
-    new_classes = DiscoverClassesInModule(
-        module, base_class, index_by_class_name, directly_constructable)
-    classes = dict(classes.items() + new_classes.items())
+    classes.extend(DiscoverClassesInModule(
+        module, base_class, one_class_per_module, directly_constructable))
   return classes
 
-@decorators.Cache
-def DiscoverClassesInModule(module, base_class, index_by_class_name=False,
+def DiscoverClassesInModule(module, base_class, one_class_per_module=False,
                             directly_constructable=False):
   """Discover all classes in |module| which subclass |base_class|.
 
@@ -90,13 +80,12 @@ def DiscoverClassesInModule(module, base_class, index_by_class_name=False,
   Args:
     module: The module to search.
     base_class: The base class to search for.
-    index_by_class_name: If True, use class name converted to
-        lowercase_with_underscores instead of module name in return dict keys.
+    one_class_per_module: If True, will only include the first class found in
+                each module.
 
-  Returns:
-    dict of {module_name: class} or {underscored_class_name: class}
+  Returns: A list of classes.
   """
-  classes = {}
+  classes = []
   for _, obj in inspect.getmembers(module):
     # Ensure object is a class.
     if not inspect.isclass(obj):
@@ -115,14 +104,11 @@ def DiscoverClassesInModule(module, base_class, index_by_class_name=False,
     if obj.__module__ != module.__name__:
       continue
 
-    if index_by_class_name:
-      key_name = camel_case.ToUnderscore(obj.__name__)
-    else:
-      key_name = module.__name__.split('.')[-1]
     if (not directly_constructable or
         classes_module.IsDirectlyConstructable(obj)):
-      classes[key_name] = obj
-
+      classes.append(obj)
+      if one_class_per_module:
+        return classes
   return classes
 
 
diff --git a/tools/telemetry/telemetry/core/discover_unittest.py b/tools/telemetry/telemetry/core/discover_unittest.py
index c124d4507851d3..c39dd2d92d0516 100644
--- a/tools/telemetry/telemetry/core/discover_unittest.py
+++ b/tools/telemetry/telemetry/core/discover_unittest.py
@@ -14,90 +14,82 @@ def setUp(self):
     self._start_dir = os.path.join(self._base_dir, 'discoverable_classes')
     self._base_class = Exception
 
+  def testDiscoverClassesWithDefaults(self):
+    classes = discover.DiscoverClasses(
+        self._start_dir, self._base_dir, self._base_class)
+
+    actual_classes = list(cls.__name__ for cls in classes)
+    expected_classes = [
+        'DummyException', 'DummyExceptionImpl1', 'DummyExceptionImpl2',
+        'DummyExceptionWithParameterImpl1', 'DummyExceptionWithParameterImpl2'
+    ]
+    self.assertItemsEqual(actual_classes, expected_classes)
+
 
-  def testDiscoverClassesWithIndexByModuleName(self):
+  def testDiscoverClassesOneClassPerModule(self):
     classes = discover.DiscoverClasses(
         self._start_dir, self._base_dir, self._base_class,
-        index_by_class_name=False)
-
-    actual_classes = dict(
-        (name, cls.__name__) for name, cls in classes.iteritems())
-    expected_classes = {
-        'another_discover_dummyclass': 'DummyExceptionWithParameterImpl1',
-        'discover_dummyclass': 'DummyException',
-        'parameter_discover_dummyclass': 'DummyExceptionWithParameterImpl2'
-    }
-    self.assertEqual(actual_classes, expected_classes)
-
-  def testDiscoverDirectlyConstructableClassesWithIndexByClassName(self):
+        one_class_per_module=True)
+
+    actual_classes = list(cls.__name__ for cls in classes)
+    expected_classes = ['DummyExceptionImpl1', 'DummyException',
+                        'DummyExceptionWithParameterImpl2']
+    self.assertItemsEqual(actual_classes, expected_classes)
+
+  def testDiscoverDirectlyConstructableClasses(self):
     classes = discover.DiscoverClasses(
         self._start_dir, self._base_dir, self._base_class,
         directly_constructable=True)
 
-    actual_classes = dict(
-        (name, cls.__name__) for name, cls in classes.iteritems())
-    expected_classes = {
-        'dummy_exception': 'DummyException',
-        'dummy_exception_impl1': 'DummyExceptionImpl1',
-        'dummy_exception_impl2': 'DummyExceptionImpl2',
-    }
-    self.assertEqual(actual_classes, expected_classes)
+    actual_classes = list(cls.__name__ for cls in classes)
+    expected_classes = [
+        'DummyException', 'DummyExceptionImpl1', 'DummyExceptionImpl2'
+    ]
+    self.assertItemsEqual(actual_classes, expected_classes)
 
-  def testDiscoverClassesWithIndexByClassName(self):
+  def testDiscoverOneDirectlyConstructableClassPerModule(self):
     classes = discover.DiscoverClasses(
-        self._start_dir, self._base_dir, self._base_class)
+        self._start_dir, self._base_dir, self._base_class,
+        directly_constructable=True, one_class_per_module=True)
 
-    actual_classes = dict(
-        (name, cls.__name__) for name, cls in classes.iteritems())
-    expected_classes = {
-        'dummy_exception': 'DummyException',
-        'dummy_exception_impl1': 'DummyExceptionImpl1',
-        'dummy_exception_impl2': 'DummyExceptionImpl2',
-        'dummy_exception_with_parameter_impl1':
-          'DummyExceptionWithParameterImpl1',
-        'dummy_exception_with_parameter_impl2':
-          'DummyExceptionWithParameterImpl2'
-    }
-    self.assertEqual(actual_classes, expected_classes)
-
-
-  def testDiscoverClassesWithPatternAndIndexByModule(self):
+    actual_classes = list(cls.__name__ for cls in classes)
+    expected_classes = ['DummyException', 'DummyExceptionImpl1']
+    self.assertItemsEqual(actual_classes, expected_classes)
+
+  def testDiscoverClassesWithPattern(self):
     classes = discover.DiscoverClasses(
         self._start_dir, self._base_dir, self._base_class,
-        pattern='another*', index_by_class_name=False)
+        pattern='another*')
 
-    actual_classes = dict(
-        (name, cls.__name__) for name, cls in classes.iteritems())
-    expected_classes = {
-        'another_discover_dummyclass': 'DummyExceptionWithParameterImpl1'
-    }
-    self.assertEqual(actual_classes, expected_classes)
+    actual_classes = list(cls.__name__ for cls in classes)
+    expected_classes = ['DummyExceptionImpl1', 'DummyExceptionImpl2',
+                        'DummyExceptionWithParameterImpl1']
+    self.assertItemsEqual(actual_classes, expected_classes)
 
-  def testDiscoverDirectlyConstructableClassesWithPatternAndIndexByClassName(
-      self):
+  def testDiscoverOneClassPerModuleWithPattern(self):
+    classes = discover.DiscoverClasses(
+        self._start_dir, self._base_dir, self._base_class,
+        pattern='another*', one_class_per_module=True)
+
+    actual_classes = list(cls.__name__ for cls in classes)
+    expected_classes = ['DummyExceptionImpl1']
+    self.assertItemsEqual(actual_classes, expected_classes)
+
+  def testDiscoverDirectlyConstructableClassesWithPattern(self):
     classes = discover.DiscoverClasses(
         self._start_dir, self._base_dir, self._base_class,
         pattern='another*', directly_constructable=True)
 
-    actual_classes = dict(
-        (name, cls.__name__) for name, cls in classes.iteritems())
-    expected_classes = {
-        'dummy_exception_impl1': 'DummyExceptionImpl1',
-        'dummy_exception_impl2': 'DummyExceptionImpl2',
-    }
-    self.assertEqual(actual_classes, expected_classes)
+    actual_classes = list(cls.__name__ for cls in classes)
+    expected_classes = ['DummyExceptionImpl1', 'DummyExceptionImpl2']
+    self.assertItemsEqual(actual_classes, expected_classes)
 
-  def testDiscoverClassesWithPatternAndIndexByClassName(self):
+  def testDiscoverOneDirectlyConstructableClassPerModuleWithPattern(self):
     classes = discover.DiscoverClasses(
         self._start_dir, self._base_dir, self._base_class,
-        pattern='another*')
+        pattern='another*', directly_constructable=True,
+        one_class_per_module=True)
 
-    actual_classes = dict(
-        (name, cls.__name__) for name, cls in classes.iteritems())
-    expected_classes = {
-        'dummy_exception_impl1': 'DummyExceptionImpl1',
-        'dummy_exception_impl2': 'DummyExceptionImpl2',
-        'dummy_exception_with_parameter_impl1':
-          'DummyExceptionWithParameterImpl1',
-    }
-    self.assertEqual(actual_classes, expected_classes)
+    actual_classes = list(cls.__name__ for cls in classes)
+    expected_classes = ['DummyExceptionImpl1']
+    self.assertItemsEqual(actual_classes, expected_classes)
diff --git a/tools/telemetry/telemetry/core/platform.py b/tools/telemetry/telemetry/core/platform.py
index a9566a945439a4..2b2ba3e1be673b 100644
--- a/tools/telemetry/telemetry/core/platform.py
+++ b/tools/telemetry/telemetry/core/platform.py
@@ -4,11 +4,11 @@
 import logging as real_logging
 import os
 
-from telemetry.core import discover
 from telemetry.core import network_controller
 from telemetry.core import tracing_controller
 from telemetry.core import util
 from telemetry.internal.platform import platform_backend as platform_backend_module
+from telemetry.util import classes_util
 
 
 _host_platform = None
@@ -39,9 +39,9 @@ def GetHostPlatform():
 def _IterAllPlatformBackendClasses():
   platform_dir = os.path.dirname(
       os.path.realpath(platform_backend_module.__file__))
-  return discover.DiscoverClasses(
+  return classes_util.DiscoverClasses(
       platform_dir, util.GetTelemetryDir(),
-      platform_backend_module.PlatformBackend).itervalues()
+      platform_backend_module.PlatformBackend)
 
 
 def GetPlatformForDevice(device, finder_options, logging=real_logging):
diff --git a/tools/telemetry/telemetry/internal/platform/profiler/profiler_finder.py b/tools/telemetry/telemetry/internal/platform/profiler/profiler_finder.py
index 33c31e56bd826d..58afd7577f72ae 100644
--- a/tools/telemetry/telemetry/internal/platform/profiler/profiler_finder.py
+++ b/tools/telemetry/telemetry/internal/platform/profiler/profiler_finder.py
@@ -4,16 +4,15 @@
 
 import os
 
-from telemetry.core import discover
 from telemetry.internal.platform import profiler
 from telemetry.core import util
+from telemetry.util import classes_util
 
 
 def _DiscoverProfilers():
   profiler_dir = os.path.dirname(__file__)
-  return discover.DiscoverClasses(profiler_dir, util.GetTelemetryDir(),
-                                  profiler.Profiler,
-                                  index_by_class_name=True).values()
+  return classes_util.DiscoverClasses(
+      profiler_dir, util.GetTelemetryDir(), profiler.Profiler)
 
 
 def FindProfiler(name):
diff --git a/tools/telemetry/telemetry/internal/platform/tracing_controller_backend.py b/tools/telemetry/telemetry/internal/platform/tracing_controller_backend.py
index 96cceae715ef42..ee318bd7a34e1c 100644
--- a/tools/telemetry/telemetry/internal/platform/tracing_controller_backend.py
+++ b/tools/telemetry/telemetry/internal/platform/tracing_controller_backend.py
@@ -4,21 +4,20 @@
 
 import os
 
-from telemetry.core import discover
 from telemetry.core import util
 from telemetry.internal.platform import tracing_agent
 from telemetry.internal.platform.tracing_agent import chrome_tracing_agent
 from telemetry.timeline import trace_data as trace_data_module
 from telemetry.timeline import tracing_category_filter
 from telemetry.timeline import tracing_options
+from telemetry.util import classes_util
 
 
 def _IterAllTracingAgentClasses():
   tracing_agent_dir = os.path.join(
       os.path.dirname(os.path.realpath(__file__)), 'tracing_agent')
-  return discover.DiscoverClasses(
-      tracing_agent_dir, util.GetTelemetryDir(),
-      tracing_agent.TracingAgent).itervalues()
+  return classes_util.DiscoverClasses(
+      tracing_agent_dir, util.GetTelemetryDir(), tracing_agent.TracingAgent)
 
 
 class TracingControllerBackend(object):
diff --git a/tools/telemetry/telemetry/internal/util/find_dependencies.py b/tools/telemetry/telemetry/internal/util/find_dependencies.py
index 6f40196fb2faee..b9592449f0d75f 100644
--- a/tools/telemetry/telemetry/internal/util/find_dependencies.py
+++ b/tools/telemetry/telemetry/internal/util/find_dependencies.py
@@ -12,11 +12,12 @@
 import zipfile
 
 from telemetry import benchmark
-from telemetry.core import discover
 from telemetry.internal.util import bootstrap
 from telemetry.internal.util import command_line
 from telemetry.internal.util import path
 from telemetry.internal.util import path_set
+from telemetry.util import classes_util
+
 
 DEPS_FILE = 'bootstrap_deps'
 
@@ -61,10 +62,9 @@ def FindPageSetDependencies(base_dir):
 
   # Add base_dir to path so our imports relative to base_dir will work.
   sys.path.append(base_dir)
-  tests = discover.DiscoverClasses(base_dir, base_dir, benchmark.Benchmark,
-                                   index_by_class_name=True)
+  tests = classes_util.DiscoverClasses(base_dir, base_dir, benchmark.Benchmark)
 
-  for test_class in tests.itervalues():
+  for test_class in tests:
     test_obj = test_class()
 
     # Ensure the test's default options are set if needed.
diff --git a/tools/telemetry/telemetry/record_wpr.py b/tools/telemetry/telemetry/record_wpr.py
index 9a668f997626b1..6f1d2bd193bd61 100644
--- a/tools/telemetry/telemetry/record_wpr.py
+++ b/tools/telemetry/telemetry/record_wpr.py
@@ -8,13 +8,13 @@
 
 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.internal.util import command_line
 from telemetry.page import page_test
+from telemetry.util import classes_util
 from telemetry.util import wpr_modes
 
 
@@ -71,15 +71,13 @@ def _GetSubclasses(base_dir, cls):
   Returns:
     dict of {underscored_class_name: benchmark class}
   """
-  return discover.DiscoverClasses(base_dir, base_dir, cls,
-                                  index_by_class_name=True)
+  return classes_util.DiscoverClassesByClassName(base_dir, base_dir, cls)
 
 
 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 _PrintAllImpl(all_items, item_name, output_stream):
diff --git a/tools/telemetry/telemetry/testing/story_set_smoke_test.py b/tools/telemetry/telemetry/testing/story_set_smoke_test.py
index 008773f5f7eaf8..d0a8d575bf6eb2 100644
--- a/tools/telemetry/telemetry/testing/story_set_smoke_test.py
+++ b/tools/telemetry/telemetry/testing/story_set_smoke_test.py
@@ -6,10 +6,10 @@
 import os
 import unittest
 
-from telemetry.core import discover
 from telemetry.internal.browser import browser_credentials
 from telemetry import page
 from telemetry import story as story_module
+from telemetry.util import classes_util
 from telemetry.wpr import archive_info
 
 
@@ -23,9 +23,9 @@ def setUp(self):
   def GetAllStorySetClasses(self, story_sets_dir, top_level_dir):
     # We can't test page sets that aren't directly constructable since we
     # don't know what arguments to put for the constructor.
-    return discover.DiscoverClasses(story_sets_dir, top_level_dir,
-                                    story_module.StorySet,
-                                    directly_constructable=True).values()
+    return classes_util.DiscoverClasses(story_sets_dir, top_level_dir,
+                                        story_module.StorySet,
+                                        directly_constructable=True)
 
   def CheckArchive(self, story_set):
     """Verify that all URLs of pages in story_set have an associated archive."""
diff --git a/tools/telemetry/telemetry/util/classes_util.py b/tools/telemetry/telemetry/util/classes_util.py
new file mode 100644
index 00000000000000..1496d896311f84
--- /dev/null
+++ b/tools/telemetry/telemetry/util/classes_util.py
@@ -0,0 +1,27 @@
+# Copyright 2015 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.
+
+from telemetry.core import discover
+from telemetry.internal.util import camel_case
+
+
+def DiscoverClasses(start_dir, top_level_dir, base_class,
+                    directly_constructable=False):
+  return discover.DiscoverClasses(start_dir, top_level_dir, base_class,
+                                  directly_constructable=directly_constructable)
+
+def DiscoverClassesByClassName(
+    start_dir, top_level_dir, base_class, directly_constructable=False):
+  classes_dict = {}
+  classes = discover.DiscoverClasses(
+      start_dir, top_level_dir, base_class,
+      directly_constructable=directly_constructable)
+  for class_obj in classes:
+    classes_dict[camel_case.ToUnderscore(class_obj.__name__)] = class_obj
+  return classes_dict
+
+def MaybeGetInstanceOfClass(target, start_dir, top_level_dir, cls):
+  classes = DiscoverClassesByClassName(
+      start_dir, top_level_dir, cls, directly_constructable=True)
+  return classes[target]() if target in classes else None
diff --git a/tools/telemetry/telemetry/value/__init__.py b/tools/telemetry/telemetry/value/__init__.py
index a2ab23e29165a2..e180dd304b1117 100644
--- a/tools/telemetry/telemetry/value/__init__.py
+++ b/tools/telemetry/telemetry/value/__init__.py
@@ -22,8 +22,9 @@
 """
 import os
 
-from telemetry.core import discover
 from telemetry.core import util
+from telemetry.util import classes_util
+
 
 # When combining a pair of Values togehter, it is sometimes ambiguous whether
 # the values should be concatenated, or one should be picked as representative.
@@ -248,9 +249,8 @@ def ListOfValuesFromListOfDicts(value_dicts, page_dict):
     page_dict: a dictionary mapping IDs to page objects.
     """
     value_dir = os.path.dirname(__file__)
-    value_classes = discover.DiscoverClasses(
-        value_dir, util.GetTelemetryDir(),
-        Value, index_by_class_name=True)
+    value_classes = classes_util.DiscoverClassesByClassName(
+        value_dir, util.GetTelemetryDir(), Value)
 
     value_json_types = dict((value_classes[x].GetJSONTypeName(), x) for x in
         value_classes)