[Telemetry] Migrate find_dependencies internals to tools/perf

tools/perf/core/find_dependencies.py

 # Copyright 2014 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 fnmatch
 import imp
 import logging
 import optparse
 import os
 import sys
 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 modulegraph import modulegraph
+from modulegraph import modulegraph  # pylint: disable=import-error
 
+from core import bootstrap
+from core import path_util
 
 DEPS_FILE = 'bootstrap_deps'
 
 
 def FindBootstrapDependencies(base_dir):
   deps_file = os.path.join(base_dir, DEPS_FILE)
   if not os.path.exists(deps_file):
     return []
   deps_paths = bootstrap.ListAllDepsPaths(deps_file)
   return set(os.path.realpath(os.path.join(
-      path.GetChromiumSrcDir(), '..', deps_path))
+      path_util.GetChromiumSrcDir(), '..', deps_path))
       for deps_path in deps_paths)
 
 
 def FindPythonDependencies(module_path):
   logging.info('Finding Python dependencies of %s' % module_path)
 
   sys_path = sys.path
   sys.path = list(sys_path)
   try:
     # Load the module to inherit its sys.path modifications.
@@ skipping 14 matching lines @@
       _, incoming_edges = graph.get_edges(node)
       message = 'Discovered %s (Imported by: %s)' % (
           node.filename, ', '.join(
               d.filename for d in incoming_edges
               if d is not None and d.filename is not None))
       logging.info(message)
 
       # This check is done after the logging/printing above to make sure that
       # we also print out the dependency edges that include python packages
       # that are not in chromium.
-      if not path.IsSubpath(module_path, path.GetChromiumSrcDir()):
+      if not path.IsSubpath(module_path, path_util.GetChromiumSrcDir()):
         continue
 
       yield module_path
       if node.packagepath is not None:
         for p in node.packagepath:
           yield p
 
   finally:
     sys.path = sys_path
 
@@ skipping 64 matching lines @@
   for target_path in target_paths:
     if not os.path.exists(target_path):
       raise ValueError('Path does not exist: %s' % target_path)
 
   dependencies = path_set.PathSet()
 
   # Including Telemetry's major entry points will (hopefully) include Telemetry
   # and all its dependencies. If the user doesn't pass any arguments, we just
   # have Telemetry.
   dependencies |= FindPythonDependencies(os.path.realpath(
-    os.path.join(path.GetTelemetryDir(), 'telemetry', 'benchmark_runner.py')))
+    os.path.join(path_util.GetTelemetryDir(),
+                 'telemetry', 'benchmark_runner.py')))
   dependencies |= FindPythonDependencies(os.path.realpath(
-    os.path.join(path.GetTelemetryDir(),
+    os.path.join(path_util.GetTelemetryDir(),
                  'telemetry', 'testing', 'run_tests.py')))
 
   # Add dependencies.
   for target_path in target_paths:
     base_dir = os.path.dirname(os.path.realpath(target_path))
 
     dependencies.add(base_dir)
     dependencies |= FindBootstrapDependencies(base_dir)
     dependencies |= FindPythonDependencies(target_path)
     if options.include_page_set_data:
       dependencies |= FindPageSetDependencies(base_dir)
 
   # Remove excluded files.
   dependencies -= FindExcludedFiles(set(dependencies), options)
 
   return dependencies
 
 
 def ZipDependencies(target_paths, dependencies, options):
-  base_dir = os.path.dirname(os.path.realpath(path.GetChromiumSrcDir()))
+  base_dir = os.path.dirname(os.path.realpath(path_util.GetChromiumSrcDir()))
 
   with zipfile.ZipFile(options.zip, 'w', zipfile.ZIP_DEFLATED) as zip_file:
     # Add dependencies to archive.
     for dependency_path in dependencies:
       path_in_archive = os.path.join(
           'telemetry', os.path.relpath(dependency_path, base_dir))
       zip_file.write(dependency_path, path_in_archive)
 
     # Add symlinks to executable paths, for ease of use.
     for target_path in target_paths:
@@ skipping 47 matching lines @@
 
   def Run(self, args):
     target_paths = args.positional_args
     dependencies = FindDependencies(target_paths, args)
     if args.zip:
       ZipDependencies(target_paths, dependencies, args)
       print 'Zip archive written to %s.' % args.zip
     else:
       print '\n'.join(sorted(dependencies))
     return 0