Extract SourceControl to module; extract common methods to bisect_utils.

tools/bisect-perf-regression.py

 #!/usr/bin/env python
 # Copyright (c) 2013 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.
 
 """Performance Test Bisect Tool
 
 This script bisects a series of changelists using binary search. It starts at
 a bad revision where a performance metric has regressed, and asks for a last
 known-good revision. It will then binary search across this revision range by
@@ skipping 28 matching lines @@
 import datetime
 import errno
 import hashlib
 import math
 import optparse
 import os
 import re
 import shlex
 import shutil
 import StringIO
-import subprocess
 import sys
 import time
 import zipfile
 
 sys.path.append(os.path.join(os.path.dirname(__file__), 'telemetry'))
 
 from auto_bisect import bisect_utils
 from auto_bisect import post_perf_builder_job as bisect_builder
+from auto_bisect import source_control as source_control_module
 from telemetry.util import cloud_storage
 
 # The additional repositories that might need to be bisected.
 # If the repository has any dependant repositories (such as skia/src needs
 # skia/include and skia/gyp to be updated), specify them in the 'depends'
 # so that they're synced appropriately.
 # Format is:
 # src: path to the working directory.
 # recurse: True if this repositry will get bisected.
 # depends: A list of other repositories that are actually part of the same
@@ skipping 68 matching lines @@
     "recurse" : False,
     "svn" : "http://skia.googlecode.com/svn/trunk/gyp",
     "depends" : None,
     "from" : ['chromium'],
     'viewvc': 'https://code.google.com/p/skia/source/detail?r=',
     'deps_var': 'None'
   },
 }
 
 DEPOT_NAMES = DEPOT_DEPS_NAME.keys()
+
 CROS_SDK_PATH = os.path.join('..', 'cros', 'chromite', 'bin', 'cros_sdk')
-CROS_VERSION_PATTERN = 'new version number from %s'
 CROS_CHROMEOS_PATTERN = 'chromeos-base/chromeos-chrome'
 CROS_TEST_KEY_PATH = os.path.join('..', 'cros', 'chromite', 'ssh_keys',
                                   'testing_rsa')
 CROS_SCRIPT_KEY_PATH = os.path.join('..', 'cros', 'src', 'scripts',
                                     'mod_for_test_scripts', 'ssh_keys',
                                     'testing_rsa')
 
 BUILD_RESULT_SUCCEED = 0
 BUILD_RESULT_FAIL = 1
 BUILD_RESULT_SKIPPED = 2
@@ skipping 248 matching lines @@
 def CalculateStandardError(values):
   """Calculates the standard error of a list of values."""
   if len(values) <= 1:
     return 0.0
 
   std_dev = CalculateStandardDeviation(values)
 
   return std_dev / math.sqrt(len(values))
 
 
-def IsStringFloat(string_to_check):
-  """Checks whether or not the given string can be converted to a floating
-  point number.
-
-  Args:
-    string_to_check: Input string to check if it can be converted to a float.
-
-  Returns:
-    True if the string can be converted to a float.
-  """
-  try:
-    float(string_to_check)
-
-    return True
-  except ValueError:
-    return False
-
-
-def IsStringInt(string_to_check):
-  """Checks whether or not the given string can be converted to a integer.
-
-  Args:
-    string_to_check: Input string to check if it can be converted to an int.
-
-  Returns:
-    True if the string can be converted to an int.
-  """
-  try:
-    int(string_to_check)
-
-    return True
-  except ValueError:
-    return False
-
-
-def IsWindowsHost():
-  """Checks whether or not the script is running on Windows.
-
-  Returns:
-    True if running on Windows.
-  """
-  return sys.platform == 'cygwin' or sys.platform.startswith('win')
-
-
-def Is64BitWindows():
-  """Returns whether or not Windows is a 64-bit version.
-
-  Returns:
-    True if Windows is 64-bit, False if 32-bit.
-  """
-  platform = os.environ['PROCESSOR_ARCHITECTURE']
-  try:
-    platform = os.environ['PROCESSOR_ARCHITEW6432']
-  except KeyError:
-    # Must not be running in WoW64, so PROCESSOR_ARCHITECTURE is correct
-    pass
-
-  return platform in ['AMD64', 'I64']
-
-
-def IsLinuxHost():
-  """Checks whether or not the script is running on Linux.
-
-  Returns:
-    True if running on Linux.
-  """
-  return sys.platform.startswith('linux')
-
-
-def IsMacHost():
-  """Checks whether or not the script is running on Mac.
-
-  Returns:
-    True if running on Mac.
-  """
-  return sys.platform.startswith('darwin')
 
 
 def GetSHA1HexDigest(contents):
   """Returns secured hash containing hexadecimal for the given contents."""
   return hashlib.sha1(contents).hexdigest()
 
 
 def GetZipFileName(build_revision=None, target_arch='ia32', patch_sha=None):
   """Gets the archive file name for the given revision."""
   def PlatformName():
     """Return a string to be used in paths for the platform."""
-    if IsWindowsHost():
+    if bisect_utils.IsWindowsHost():
       # Build archive for x64 is still stored with 'win32'suffix
       # (chromium_utils.PlatformName()).
-      if Is64BitWindows() and target_arch == 'x64':
+      if bisect_utils.Is64BitWindows() and target_arch == 'x64':
         return 'win32'
       return 'win32'
-    if IsLinuxHost():
+    if bisect_utils.IsLinuxHost():
       # Android builds too are archived with full-build-linux* prefix.
       return 'linux'
-    if IsMacHost():
+    if bisect_utils.IsMacHost():
       return 'mac'
     raise NotImplementedError('Unknown platform "%s".' % sys.platform)
 
   base_name = 'full-build-%s' % PlatformName()
   if not build_revision:
     return base_name
   if patch_sha:
     build_revision = '%s_%s' % (build_revision , patch_sha)
   return '%s_%s.zip' % (base_name, build_revision)
 
 
 def GetRemoteBuildPath(build_revision, target_platform='chromium',
                        target_arch='ia32', patch_sha=None):
   """Compute the url to download the build from."""
   def GetGSRootFolderName(target_platform):
     """Gets Google Cloud Storage root folder names"""
-    if IsWindowsHost():
-      if Is64BitWindows() and target_arch == 'x64':
+    if bisect_utils.IsWindowsHost():
+      if bisect_utils.Is64BitWindows() and target_arch == 'x64':
         return 'Win x64 Builder'
       return 'Win Builder'
-    if IsLinuxHost():
+    if bisect_utils.IsLinuxHost():
       if target_platform == 'android':
         return 'android_perf_rel'
       return 'Linux Builder'
-    if IsMacHost():
+    if bisect_utils.IsMacHost():
       return 'Mac Builder'
     raise NotImplementedError('Unsupported Platform "%s".' % sys.platform)
 
   base_filename = GetZipFileName(
       build_revision, target_arch, patch_sha)
   builder_folder = GetGSRootFolderName(target_platform)
   return '%s/%s' % (builder_folder, base_filename)
 
 
 def FetchFromCloudStorage(bucket_name, source_path, destination_path):
@@ skipping 45 matching lines @@
   # handle links and file bits (executable), which is much
   # easier then trying to do that with ZipInfo options.
   #
   # The Mac Version of unzip unfortunately does not support Zip64, whereas
   # the python module does, so we have to fallback to the python zip module
   # on Mac if the filesize is greater than 4GB.
   #
   # On Windows, try to use 7z if it is installed, otherwise fall back to python
   # zip module and pray we don't have files larger than 512MB to unzip.
   unzip_cmd = None
-  if ((IsMacHost() and os.path.getsize(filename) < 4 * 1024 * 1024 * 1024)
-      or IsLinuxHost()):
+  if ((bisect_utils.IsMacHost()
+       and os.path.getsize(filename) < 4 * 1024 * 1024 * 1024)
+      or bisect_utils.IsLinuxHost()):
     unzip_cmd = ['unzip', '-o']
-  elif IsWindowsHost() and os.path.exists('C:\\Program Files\\7-Zip\\7z.exe'):
+  elif (bisect_utils.IsWindowsHost()
+        and os.path.exists('C:\\Program Files\\7-Zip\\7z.exe')):
     unzip_cmd = ['C:\\Program Files\\7-Zip\\7z.exe', 'x', '-y']
 
   if unzip_cmd:
     # Make sure path is absolute before changing directories.
     filepath = os.path.abspath(filename)
     saved_dir = os.getcwd()
     os.chdir(output_dir)
     command = unzip_cmd + [filepath]
-    result = RunProcess(command)
+    result = bisect_utils.RunProcess(command)
     os.chdir(saved_dir)
     if result:
       raise IOError('unzip failed: %s => %s' % (str(command), result))
   else:
-    assert IsWindowsHost() or IsMacHost()
+    assert bisect_utils.IsWindowsHost() or bisect_utils.IsMacHost()
     zf = zipfile.ZipFile(filename)
     for name in zf.namelist():
       if verbose:
         print 'Extracting %s' % name
       zf.extract(name, output_dir)
-      if IsMacHost():
+      if bisect_utils.IsMacHost():
         # Restore permission bits.
         os.chmod(os.path.join(output_dir, name),
                  zf.getinfo(name).external_attr >> 16L)
 
 
-def RunProcess(command):
-  """Runs an arbitrary command.
-
-  If output from the call is needed, use RunProcessAndRetrieveOutput instead.
-
-  Args:
-    command: A list containing the command and args to execute.
-
-  Returns:
-    The return code of the call.
-  """
-  # On Windows, use shell=True to get PATH interpretation.
-  shell = IsWindowsHost()
-  return subprocess.call(command, shell=shell)
-
-
-def RunProcessAndRetrieveOutput(command, cwd=None):
-  """Runs an arbitrary command, returning its output and return code.
-
-  Since output is collected via communicate(), there will be no output until
-  the call terminates. If you need output while the program runs (ie. so
-  that the buildbot doesn't terminate the script), consider RunProcess().
-
-  Args:
-    command: A list containing the command and args to execute.
-    cwd: A directory to change to while running the command. The command can be
-        relative to this directory. If this is None, the command will be run in
-        the current directory.
-
-  Returns:
-    A tuple of the output and return code.
-  """
-  if cwd:
-    original_cwd = os.getcwd()
-    os.chdir(cwd)
-
-  # On Windows, use shell=True to get PATH interpretation.
-  shell = IsWindowsHost()
-  proc = subprocess.Popen(command, shell=shell, stdout=subprocess.PIPE)
-  (output, _) = proc.communicate()
-
-  if cwd:
-    os.chdir(original_cwd)
-
-  return (output, proc.returncode)
-
-
-def RunGit(command, cwd=None):
-  """Run a git subcommand, returning its output and return code.
-
-  Args:
-    command: A list containing the args to git.
-    cwd: A directory to change to while running the git command (optional).
-
-  Returns:
-    A tuple of the output and return code.
-  """
-  command = ['git'] + command
-
-  return RunProcessAndRetrieveOutput(command, cwd=cwd)
-
-
-def CheckRunGit(command, cwd=None):
-  """Run a git subcommand, returning its output and return code. Asserts if
-  the return code of the call is non-zero.
-
-  Args:
-    command: A list containing the args to git.
-
-  Returns:
-    A tuple of the output and return code.
-  """
-  (output, return_code) = RunGit(command, cwd=cwd)
-
-  assert not return_code, 'An error occurred while running'\
-                          ' "git %s"' % ' '.join(command)
-  return output
 
 
 def SetBuildSystemDefault(build_system, use_goma, goma_dir):
   """Sets up any environment variables needed to build with the specified build
   system.
 
   Args:
     build_system: A string specifying build system. Currently only 'ninja' or
         'make' are supported."""
   if build_system == 'ninja':
     gyp_var = os.getenv('GYP_GENERATORS')
 
     if not gyp_var or not 'ninja' in gyp_var:
       if gyp_var:
         os.environ['GYP_GENERATORS'] = gyp_var + ',ninja'
       else:
         os.environ['GYP_GENERATORS'] = 'ninja'
 
-      if IsWindowsHost():
+      if bisect_utils.IsWindowsHost():
         os.environ['GYP_DEFINES'] = 'component=shared_library '\
             'incremental_chrome_dll=1 disable_nacl=1 fastbuild=1 '\
             'chromium_win_pch=0'
 
   elif build_system == 'make':
     os.environ['GYP_GENERATORS'] = 'make'
   else:
     raise RuntimeError('%s build not supported.' % build_system)
 
   if use_goma:
     os.environ['GYP_DEFINES'] = '%s %s' % (os.getenv('GYP_DEFINES', ''),
                                               'use_goma=1')
     if goma_dir:
       os.environ['GYP_DEFINES'] += ' gomadir=%s' % goma_dir
 
 
 def BuildWithMake(threads, targets, build_type='Release'):
   cmd = ['make', 'BUILDTYPE=%s' % build_type]
 
   if threads:
     cmd.append('-j%d' % threads)
 
   cmd += targets
 
-  return_code = RunProcess(cmd)
+  return_code = bisect_utils.RunProcess(cmd)
 
   return not return_code
 
 
 def BuildWithNinja(threads, targets, build_type='Release'):
   cmd = ['ninja', '-C', os.path.join('out', build_type)]
 
   if threads:
     cmd.append('-j%d' % threads)
 
   cmd += targets
 
-  return_code = RunProcess(cmd)
+  return_code = bisect_utils.RunProcess(cmd)
 
   return not return_code
 
 
 def BuildWithVisualStudio(targets, build_type='Release'):
   path_to_devenv = os.path.abspath(
       os.path.join(os.environ['VS100COMNTOOLS'], '..', 'IDE', 'devenv.com'))
   path_to_sln = os.path.join(os.getcwd(), 'chrome', 'chrome.sln')
   cmd = [path_to_devenv, '/build', build_type, path_to_sln]
 
   for t in targets:
     cmd.extend(['/Project', t])
 
-  return_code = RunProcess(cmd)
+  return_code = bisect_utils.RunProcess(cmd)
 
   return not return_code
 
 
 def WriteStringToFile(text, file_name):
   try:
     with open(file_name, "wb") as f:
       f.write(text)
   except IOError as e:
     raise RuntimeError('Error writing to file [%s]' % file_name )
@@ skipping 21 matching lines @@
 
 class Builder(object):
   """Builder is used by the bisect script to build relevant targets and deploy.
   """
   def __init__(self, opts):
     """Performs setup for building with target build system.
 
     Args:
         opts: Options parsed from command line.
     """
-    if IsWindowsHost():
+    if bisect_utils.IsWindowsHost():
       if not opts.build_preference:
         opts.build_preference = 'msvs'
 
       if opts.build_preference == 'msvs':
         if not os.getenv('VS100COMNTOOLS'):
           raise RuntimeError(
               'Path to visual studio could not be determined.')
       else:
         SetBuildSystemDefault(opts.build_preference, opts.use_goma,
                               opts.goma_dir)
@@ skipping 24 matching lines @@
 
   def Build(self, depot, opts):
     raise NotImplementedError()
 
   def GetBuildOutputDirectory(self, opts, src_dir=None):
     """Returns the path to the build directory, relative to the checkout root.
 
       Assumes that the current working directory is the checkout root.
     """
     src_dir = src_dir or 'src'
-    if opts.build_preference == 'ninja' or IsLinuxHost():
+    if opts.build_preference == 'ninja' or bisect_utils.IsLinuxHost():
       return os.path.join(src_dir, 'out')
-    if IsMacHost():
+    if bisect_utils.IsMacHost():
       return os.path.join(src_dir, 'xcodebuild')
-    if IsWindowsHost():
+    if bisect_utils.IsWindowsHost():
       return os.path.join(src_dir, 'build')
     raise NotImplementedError('Unexpected platform %s' % sys.platform)
 
 
 class DesktopBuilder(Builder):
   """DesktopBuilder is used to build Chromium on linux/mac/windows."""
   def __init__(self, opts):
     super(DesktopBuilder, self).__init__(opts)
 
   def Build(self, depot, opts):
@@ skipping 12 matching lines @@
     threads = None
     if opts.use_goma:
       threads = 64
 
     build_success = False
     if opts.build_preference == 'make':
       build_success = BuildWithMake(threads, targets, opts.target_build_type)
     elif opts.build_preference == 'ninja':
       build_success = BuildWithNinja(threads, targets, opts.target_build_type)
     elif opts.build_preference == 'msvs':
-      assert IsWindowsHost(), 'msvs is only supported on Windows.'
+      assert bisect_utils.IsWindowsHost(), 'msvs is only supported on Windows.'
       build_success = BuildWithVisualStudio(targets, opts.target_build_type)
     else:
       assert False, 'No build system defined.'
     return build_success
 
 
 class AndroidBuilder(Builder):
   """AndroidBuilder is used to build on android."""
   def __init__(self, opts):
     super(AndroidBuilder, self).__init__(opts)
@@ skipping 51 matching lines @@
         True if successful.
     """
     try:
       # Keys will most likely be set to 0640 after wiping the chroot.
       os.chmod(CROS_SCRIPT_KEY_PATH, 0600)
       os.chmod(CROS_TEST_KEY_PATH, 0600)
       cmd = [CROS_SDK_PATH, '--', './bin/cros_image_to_target.py',
              '--remote=%s' % opts.cros_remote_ip,
              '--board=%s' % opts.cros_board, '--test', '--verbose']
 
-      return_code = RunProcess(cmd)
+      return_code = bisect_utils.RunProcess(cmd)
       return not return_code
     except OSError, e:
       return False
 
   def BuildPackages(self, opts, depot):
     """Builds packages for cros.
 
     Args:
         opts: Program options containing cros_board.
         depot: The depot being bisected.
 
     Returns:
         True if successful.
     """
     cmd = [CROS_SDK_PATH]
 
     if depot != 'cros':
       path_to_chrome = os.path.join(os.getcwd(), '..')
       cmd += ['--chrome_root=%s' % path_to_chrome]
 
     cmd += ['--']
 
     if depot != 'cros':
       cmd += ['CHROME_ORIGIN=LOCAL_SOURCE']
 
     cmd += ['BUILDTYPE=%s' % opts.target_build_type, './build_packages',
         '--board=%s' % opts.cros_board]
-    return_code = RunProcess(cmd)
+    return_code = bisect_utils.RunProcess(cmd)
 
     return not return_code
 
   def BuildImage(self, opts, depot):
     """Builds test image for cros.
 
     Args:
         opts: Program options containing cros_board.
         depot: The depot being bisected.
 
     Returns:
         True if successful.
     """
     cmd = [CROS_SDK_PATH]
 
     if depot != 'cros':
       path_to_chrome = os.path.join(os.getcwd(), '..')
       cmd += ['--chrome_root=%s' % path_to_chrome]
 
     cmd += ['--']
 
     if depot != 'cros':
       cmd += ['CHROME_ORIGIN=LOCAL_SOURCE']
 
     cmd += ['BUILDTYPE=%s' % opts.target_build_type, '--', './build_image',
         '--board=%s' % opts.cros_board, 'test']
 
-    return_code = RunProcess(cmd)
+    return_code = bisect_utils.RunProcess(cmd)
 
     return not return_code
 
   def Build(self, depot, opts):
     """Builds targets using options passed into the script.
 
     Args:
         depot: Current depot being bisected.
         opts: The options parsed from the command line.
 
     Returns:
         True if build was successful.
     """
     if self.BuildPackages(opts, depot):
       if self.BuildImage(opts, depot):
         return self.ImageToTarget(opts)
     return False
 
 
-class SourceControl(object):
-  """SourceControl is an abstraction over the underlying source control
-  system used for chromium. For now only git is supported, but in the
-  future, the svn workflow could be added as well."""
-  def __init__(self):
-    super(SourceControl, self).__init__()
-
-  def SyncToRevisionWithGClient(self, revision):
-    """Uses gclient to sync to the specified revision.
-
-    ie. gclient sync --revision <revision>
-
-    Args:
-      revision: The git SHA1 or svn CL (depending on workflow).
-
-    Returns:
-      The return code of the call.
-    """
-    return bisect_utils.RunGClient(['sync', '--verbose', '--reset', '--force',
-        '--delete_unversioned_trees', '--nohooks', '--revision', revision])
-
-  def SyncToRevisionWithRepo(self, timestamp):
-    """Uses repo to sync all the underlying git depots to the specified
-    time.
-
-    Args:
-      timestamp: The unix timestamp to sync to.
-
-    Returns:
-      The return code of the call.
-    """
-    return bisect_utils.RunRepoSyncAtTimestamp(timestamp)
-
-
-class GitSourceControl(SourceControl):
-  """GitSourceControl is used to query the underlying source control. """
-  def __init__(self, opts):
-    super(GitSourceControl, self).__init__()
-    self.opts = opts
-
-  def IsGit(self):
-    return True
-
-  def GetRevisionList(self, revision_range_end, revision_range_start, cwd=None):
-    """Retrieves a list of revisions between |revision_range_start| and
-    |revision_range_end|.
-
-    Args:
-      revision_range_end: The SHA1 for the end of the range.
-      revision_range_start: The SHA1 for the beginning of the range.
-
-    Returns:
-      A list of the revisions between |revision_range_start| and
-      |revision_range_end| (inclusive).
-    """
-    revision_range = '%s..%s' % (revision_range_start, revision_range_end)
-    cmd = ['log', '--format=%H', '-10000', '--first-parent', revision_range]
-    log_output = CheckRunGit(cmd, cwd=cwd)
-
-    revision_hash_list = log_output.split()
-    revision_hash_list.append(revision_range_start)
-
-    return revision_hash_list
-
-  def SyncToRevision(self, revision, sync_client=None):
-    """Syncs to the specified revision.
-
-    Args:
-      revision: The revision to sync to.
-      use_gclient: Specifies whether or not we should sync using gclient or
-        just use source control directly.
-
-    Returns:
-      True if successful.
-    """
-
-    if not sync_client:
-      results = RunGit(['checkout', revision])[1]
-    elif sync_client == 'gclient':
-      results = self.SyncToRevisionWithGClient(revision)
-    elif sync_client == 'repo':
-      results = self.SyncToRevisionWithRepo(revision)
-
-    return not results
-
-  def ResolveToRevision(self, revision_to_check, depot, search, cwd=None):
-    """If an SVN revision is supplied, try to resolve it to a git SHA1.
-
-    Args:
-      revision_to_check: The user supplied revision string that may need to be
-        resolved to a git SHA1.
-      depot: The depot the revision_to_check is from.
-      search: The number of changelists to try if the first fails to resolve
-        to a git hash. If the value is negative, the function will search
-        backwards chronologically, otherwise it will search forward.
-
-    Returns:
-      A string containing a git SHA1 hash, otherwise None.
-    """
-    # Android-chrome is git only, so no need to resolve this to anything else.
-    if depot == 'android-chrome':
-      return revision_to_check
-
-    if depot != 'cros':
-      if not IsStringInt(revision_to_check):
-        return revision_to_check
-
-      depot_svn = 'svn://svn.chromium.org/chrome/trunk/src'
-
-      if depot != 'chromium':
-        depot_svn = DEPOT_DEPS_NAME[depot]['svn']
-
-      svn_revision = int(revision_to_check)
-      git_revision = None
-
-      if search > 0:
-        search_range = xrange(svn_revision, svn_revision + search, 1)
-      else:
-        search_range = xrange(svn_revision, svn_revision + search, -1)
-
-      for i in search_range:
-        svn_pattern = 'git-svn-id: %s@%d' % (depot_svn, i)
-        cmd = ['log', '--format=%H', '-1', '--grep', svn_pattern,
-               'origin/master']
-
-        (log_output, return_code) = RunGit(cmd, cwd=cwd)
-
-        assert not return_code, 'An error occurred while running'\
-                                ' "git %s"' % ' '.join(cmd)
-
-        if not return_code:
-          log_output = log_output.strip()
-
-          if log_output:
-            git_revision = log_output
-
-            break
-
-      return git_revision
-    else:
-      if IsStringInt(revision_to_check):
-        return int(revision_to_check)
-      else:
-        cwd = os.getcwd()
-        os.chdir(os.path.join(os.getcwd(), 'src', 'third_party',
-            'chromiumos-overlay'))
-        pattern = CROS_VERSION_PATTERN % revision_to_check
-        cmd = ['log', '--format=%ct', '-1', '--grep', pattern]
-
-        git_revision = None
-
-        log_output = CheckRunGit(cmd, cwd=cwd)
-        if log_output:
-          git_revision = log_output
-          git_revision = int(log_output.strip())
-        os.chdir(cwd)
-
-        return git_revision
-
-  def IsInProperBranch(self):
-    """Confirms they're in the master branch for performing the bisection.
-    This is needed or gclient will fail to sync properly.
-
-    Returns:
-      True if the current branch on src is 'master'
-    """
-    cmd = ['rev-parse', '--abbrev-ref', 'HEAD']
-    log_output = CheckRunGit(cmd)
-    log_output = log_output.strip()
-
-    return log_output == "master"
-
-  def SVNFindRev(self, revision, cwd=None):
-    """Maps directly to the 'git svn find-rev' command.
-
-    Args:
-      revision: The git SHA1 to use.
-
-    Returns:
-      An integer changelist #, otherwise None.
-    """
-
-    cmd = ['svn', 'find-rev', revision]
-
-    output = CheckRunGit(cmd, cwd)
-    svn_revision = output.strip()
-
-    if IsStringInt(svn_revision):
-      return int(svn_revision)
-
-    return None
-
-  def QueryRevisionInfo(self, revision, cwd=None):
-    """Gathers information on a particular revision, such as author's name,
-    email, subject, and date.
-
-    Args:
-      revision: Revision you want to gather information on.
-    Returns:
-      A dict in the following format:
-      {
-        'author': %s,
-        'email': %s,
-        'date': %s,
-        'subject': %s,
-        'body': %s,
-      }
-    """
-    commit_info = {}
-
-    formats = ['%cN', '%cE', '%s', '%cD', '%b']
-    targets = ['author', 'email', 'subject', 'date', 'body']
-
-    for i in xrange(len(formats)):
-      cmd = ['log', '--format=%s' % formats[i], '-1', revision]
-      output = CheckRunGit(cmd, cwd=cwd)
-      commit_info[targets[i]] = output.rstrip()
-
-    return commit_info
-
-  def CheckoutFileAtRevision(self, file_name, revision, cwd=None):
-    """Performs a checkout on a file at the given revision.
-
-    Returns:
-      True if successful.
-    """
-    return not RunGit(['checkout', revision, file_name], cwd=cwd)[1]
-
-  def RevertFileToHead(self, file_name):
-    """Unstages a file and returns it to HEAD.
-
-    Returns:
-      True if successful.
-    """
-    # Reset doesn't seem to return 0 on success.
-    RunGit(['reset', 'HEAD', file_name])
-
-    return not RunGit(['checkout', bisect_utils.FILE_DEPS_GIT])[1]
-
-  def QueryFileRevisionHistory(self, filename, revision_start, revision_end):
-    """Returns a list of commits that modified this file.
-
-    Args:
-        filename: Name of file.
-        revision_start: Start of revision range.
-        revision_end: End of revision range.
-
-    Returns:
-        Returns a list of commits that touched this file.
-    """
-    cmd = ['log', '--format=%H', '%s~1..%s' % (revision_start, revision_end),
-           filename]
-    output = CheckRunGit(cmd)
-
-    return [o for o in output.split('\n') if o]
 
 
 class BisectPerformanceMetrics(object):
   """This class contains functionality to perform a bisection of a range of
   revisions to narrow down where performance regressions may have occurred.
 
   The main entry-point is the Run method.
   """
 
   def __init__(self, source_control, opts):
@@ skipping 40 matching lines @@
       cwd = os.getcwd()
       self.ChangeToDepotWorkingDirectory('cros')
 
       # Print the commit timestamps for every commit in the revision time
       # range. We'll sort them and bisect by that. There is a remote chance that
       # 2 (or more) commits will share the exact same timestamp, but it's
       # probably safe to ignore that case.
       cmd = ['repo', 'forall', '-c',
           'git log --format=%%ct --before=%d --after=%d' % (
           revision_range_end, revision_range_start)]
-      (output, return_code) = RunProcessAndRetrieveOutput(cmd)
+      (output, return_code) = bisect_utils.RunProcessAndRetrieveOutput(cmd)
 
       assert not return_code, 'An error occurred while running'\
                               ' "%s"' % ' '.join(cmd)
 
       os.chdir(cwd)
 
       revision_work_list = list(set(
-          [int(o) for o in output.split('\n') if IsStringInt(o)]))
+          [int(o) for o in output.split('\n') if bisect_utils.IsStringInt(o)]))
       revision_work_list = sorted(revision_work_list, reverse=True)
     else:
       cwd = self._GetDepotDirectory(depot)
       revision_work_list = self.source_control.GetRevisionList(bad_revision,
           good_revision, cwd=cwd)
 
     return revision_work_list
 
   def _GetV8BleedingEdgeFromV8TrunkIfMappable(self, revision):
     svn_revision = self.source_control.SVNFindRev(revision)
 
-    if IsStringInt(svn_revision):
+    if bisect_utils.IsStringInt(svn_revision):
       # V8 is tricky to bisect, in that there are only a few instances when
       # we can dive into bleeding_edge and get back a meaningful result.
       # Try to detect a V8 "business as usual" case, which is when:
       #  1. trunk revision N has description "Version X.Y.Z"
       #  2. bleeding_edge revision (N-1) has description "Prepare push to
       #     trunk. Now working on X.Y.(Z+1)."
       #
       # As of 01/24/2014, V8 trunk descriptions are formatted:
       # "Version 3.X.Y (based on bleeding_edge revision rZ)"
       # So we can just try parsing that out first and fall back to the old way.
@@ skipping 10 matching lines @@
       if regex_results:
         git_revision = None
 
         # Look for "based on bleeding_edge" and parse out revision
         if 'based on bleeding_edge' in revision_info['subject']:
           try:
             bleeding_edge_revision = revision_info['subject'].split(
                 'bleeding_edge revision r')[1]
             bleeding_edge_revision = int(bleeding_edge_revision.split(')')[0])
             git_revision = self.source_control.ResolveToRevision(
-                bleeding_edge_revision, 'v8_bleeding_edge', 1,
+                bleeding_edge_revision, 'v8_bleeding_edge', DEPOT_DEPS_NAME, 1,
                 cwd=v8_bleeding_edge_dir)
             return git_revision
           except (IndexError, ValueError):
             pass
 
         if not git_revision:
           # Wasn't successful, try the old way of looking for "Prepare push to"
           git_revision = self.source_control.ResolveToRevision(
-              int(svn_revision) - 1, 'v8_bleeding_edge', -1,
+              int(svn_revision) - 1, 'v8_bleeding_edge', DEPOT_DEPS_NAME, -1,
               cwd=v8_bleeding_edge_dir)
 
           if git_revision:
             revision_info = self.source_control.QueryRevisionInfo(git_revision,
                 cwd=v8_bleeding_edge_dir)
 
             if 'Prepare push to trunk' in revision_info['subject']:
               return git_revision
     return None
 
   def _GetNearestV8BleedingEdgeFromTrunk(self, revision, search_forward=True):
     cwd = self._GetDepotDirectory('v8')
     cmd = ['log', '--format=%ct', '-1', revision]
-    output = CheckRunGit(cmd, cwd=cwd)
+    output = bisect_utils.CheckRunGit(cmd, cwd=cwd)
     commit_time = int(output)
     commits = []
 
     if search_forward:
       cmd = ['log', '--format=%H', '-10', '--after=%d' % commit_time,
           'origin/master']
-      output = CheckRunGit(cmd, cwd=cwd)
+      output = bisect_utils.CheckRunGit(cmd, cwd=cwd)
       output = output.split()
       commits = output
       commits = reversed(commits)
     else:
       cmd = ['log', '--format=%H', '-10', '--before=%d' % commit_time,
           'origin/master']
-      output = CheckRunGit(cmd, cwd=cwd)
+      output = bisect_utils.CheckRunGit(cmd, cwd=cwd)
       output = output.split()
       commits = output
 
     bleeding_edge_revision = None
 
     for c in commits:
       bleeding_edge_revision = self._GetV8BleedingEdgeFromV8TrunkIfMappable(c)
       if bleeding_edge_revision:
         break
 
@@ skipping 92 matching lines @@
 
     results = {}
 
     if depot == 'chromium' or depot == 'android-chrome':
       results = self._ParseRevisionsFromDEPSFile(depot)
       os.chdir(cwd)
     elif depot == 'cros':
       cmd = [CROS_SDK_PATH, '--', 'portageq-%s' % self.opts.cros_board,
              'best_visible', '/build/%s' % self.opts.cros_board, 'ebuild',
              CROS_CHROMEOS_PATTERN]
-      (output, return_code) = RunProcessAndRetrieveOutput(cmd)
+      (output, return_code) = bisect_utils.RunProcessAndRetrieveOutput(cmd)
 
       assert not return_code, 'An error occurred while running' \
                               ' "%s"' % ' '.join(cmd)
 
       if len(output) > CROS_CHROMEOS_PATTERN:
         output = output[len(CROS_CHROMEOS_PATTERN):]
 
       if len(output) > 1:
         output = output.split('_')[0]
 
         if len(output) > 3:
           contents = output.split('.')
 
           version = contents[2]
 
           if contents[3] != '0':
             warningText = 'Chrome version: %s.%s but using %s.0 to bisect.' % \
                 (version, contents[3], version)
             if not warningText in self.warnings:
               self.warnings.append(warningText)
 
           cwd = os.getcwd()
           self.ChangeToDepotWorkingDirectory('chromium')
-          return_code = CheckRunGit(['log', '-1', '--format=%H',
-              '--author=chrome-release@google.com', '--grep=to %s' % version,
-              'origin/master'])
+          cmd = ['log', '-1', '--format=%H',
+                 '--author=chrome-release@google.com',
+                 '--grep=to %s' % version, 'origin/master']
+          return_code = bisect_utils.CheckRunGit(cmd)
           os.chdir(cwd)
 
           results['chromium'] = output.strip()
     elif depot == 'v8':
       # We can't try to map the trunk revision to bleeding edge yet, because
       # we don't know which direction to try to search in. Have to wait until
       # the bisect has narrowed the results down to 2 v8 rolls.
       results['v8_bleeding_edge'] = None
 
     return results
@@ skipping 193 matching lines @@
     # Get SVN revision for the given SHA.
     svn_revision = self.source_control.SVNFindRev(revision)
     if not svn_revision:
       raise RuntimeError(
           'Failed to determine SVN revision for %s' % revision)
 
     def GetBuilderNameAndBuildTime(target_platform, target_arch='ia32'):
       """Gets builder bot name and buildtime in seconds based on platform."""
       # Bot names should match the one listed in tryserver.chromium's
       # master.cfg which produces builds for bisect.
-      if IsWindowsHost():
-        if Is64BitWindows() and target_arch == 'x64':
+      if bisect_utils.IsWindowsHost():
+        if bisect_utils.Is64BitWindows() and target_arch == 'x64':
           return ('win_perf_bisect_builder', MAX_WIN_BUILD_TIME)
         return ('win_perf_bisect_builder', MAX_WIN_BUILD_TIME)
-      if IsLinuxHost():
+      if bisect_utils.IsLinuxHost():
         if target_platform == 'android':
           return ('android_perf_bisect_builder', MAX_LINUX_BUILD_TIME)
         return ('linux_perf_bisect_builder', MAX_LINUX_BUILD_TIME)
-      if IsMacHost():
+      if bisect_utils.IsMacHost():
         return ('mac_perf_bisect_builder', MAX_MAC_BUILD_TIME)
       raise NotImplementedError('Unsupported Platform "%s".' % sys.platform)
     if not fetch_build:
       return False
 
     bot_name, build_timeout = GetBuilderNameAndBuildTime(
        self.opts.target_platform, self.opts.target_arch)
     builder_host = self.opts.builder_host
     builder_port = self.opts.builder_port
     # Create a unique ID for each build request posted to tryserver builders.
@@ skipping 175 matching lines @@
       depot: Current depot being bisected.
       revision: A git hash revision of the dependency repository.
 
     Returns:
       A tuple with git hash of chromium revision and DEPS patch text.
     """
     deps_file_path = os.path.join(self.src_cwd, bisect_utils.FILE_DEPS)
     if not os.path.exists(deps_file_path):
       raise RuntimeError('DEPS file does not exists.[%s]' % deps_file_path)
     # Get current chromium revision (git hash).
-    chromium_sha = CheckRunGit(['rev-parse', 'HEAD']).strip()
+    cmd = ['rev-parse', 'HEAD']
+    chromium_sha = bisect_utils.CheckRunGit(cmd).strip()
     if not chromium_sha:
       raise RuntimeError('Failed to determine Chromium revision for %s' %
                          revision)
     if ('chromium' in DEPOT_DEPS_NAME[depot]['from'] or
         'v8' in DEPOT_DEPS_NAME[depot]['from']):
       # Checkout DEPS file for the current chromium revision.
       if self.source_control.CheckoutFileAtRevision(bisect_utils.FILE_DEPS,
                                                     chromium_sha,
                                                     cwd=self.src_cwd):
         if self.UpdateDeps(revision, depot, deps_file_path):
           diff_command = ['diff',
                           '--src-prefix=src/',
                           '--dst-prefix=src/',
                           '--no-ext-diff',
                            bisect_utils.FILE_DEPS]
-          diff_text = CheckRunGit(diff_command, cwd=self.src_cwd)
+          diff_text = bisect_utils.CheckRunGit(
+              diff_command, cwd=self.src_cwd)
           return (chromium_sha, ChangeBackslashToSlashInPatch(diff_text))
         else:
           raise RuntimeError('Failed to update DEPS file for chromium: [%s]' %
                              chromium_sha)
       else:
         raise RuntimeError('DEPS checkout Failed for chromium revision : [%s]' %
                            chromium_sha)
     return (None, None)
 
   def BuildCurrentRevision(self, depot, revision=None):
@@ skipping 112 matching lines @@
           single_result_match.group('VALUE')):
         values_list += [single_result_match.group('VALUE')]
       elif (not multi_results_match is None and
             multi_results_match.group('VALUES')):
         metric_values = multi_results_match.group('VALUES')
         values_list += metric_values.split(',')
       elif (not mean_stddev_match is None and
             mean_stddev_match.group('MEAN')):
         values_list += [mean_stddev_match.group('MEAN')]
 
-    values_list = [float(v) for v in values_list if IsStringFloat(v)]
+    values_list = [float(v) for v in values_list
+                   if bisect_utils.IsStringFloat(v)]
 
     # If the metric is times/t, we need to sum the timings in order to get
     # similar regression results as the try-bots.
     metrics_to_sum = [['times', 't'], ['times', 'page_load_time'],
         ['cold_times', 'page_load_time'], ['warm_times', 'page_load_time']]
 
     if metric in metrics_to_sum:
       if values_list:
         values_list = [reduce(lambda x, y: float(x) + float(y), values_list)]
 
@@ skipping 43 matching lines @@
             # Check 2 cases, --arg=<val> and --arg <val>
             if len(current_arg_split) == 2:
               arg_dict[arg_to_parse] = current_arg_split[1]
             elif i + 1 < len(command_args):
               arg_dict[arg_to_parse] = command_args[i+1]
 
       path_to_generate = os.path.join('tools', 'perf', 'generate_profile')
 
       if arg_dict.has_key('--profile-dir') and arg_dict.has_key('--browser'):
         profile_path, profile_type = os.path.split(arg_dict['--profile-dir'])
-        return not RunProcess(['python', path_to_generate,
+        return not bisect_utils.RunProcess(['python', path_to_generate,
             '--profile-type-to-generate', profile_type,
             '--browser', arg_dict['--browser'], '--output-dir', profile_path])
       return False
     return True
 
   def _IsBisectModeUsingMetric(self):
     return self.opts.bisect_mode in [BISECT_MODE_MEAN, BISECT_MODE_STD_DEV]
 
   def _IsBisectModeReturnCode(self):
     return self.opts.bisect_mode in [BISECT_MODE_RETURN_CODE]
 
   def _IsBisectModeStandardDeviation(self):
     return self.opts.bisect_mode in [BISECT_MODE_STD_DEV]
 
   def GetCompatibleCommand(self, command_to_run, revision, depot):
     # Prior to crrev.com/274857 *only* android-chromium-testshell
     # Then until crrev.com/276628 *both* (android-chromium-testshell and
     # android-chrome-shell) work. After that rev 276628 *only*
     # android-chrome-shell works. bisect-perf-reggresion.py script should
     # handle these cases and set appropriate browser type based on revision.
     if self.opts.target_platform in ['android']:
       # When its a third_party depot, get the chromium revision.
       if depot != 'chromium':
-        revision = CheckRunGit(['rev-parse', 'HEAD'], cwd=self.src_cwd).strip()
+        revision = bisect_utils.CheckRunGit(
+            ['rev-parse', 'HEAD'], cwd=self.src_cwd).strip()
       svn_revision = self.source_control.SVNFindRev(revision, cwd=self.src_cwd)
       if not svn_revision:
         return command_to_run
       cmd_re = re.compile('--browser=(?P<browser_type>\S+)')
       matches = cmd_re.search(command_to_run)
-      if IsStringInt(svn_revision) and matches:
+      if bisect_utils.IsStringInt(svn_revision) and matches:
         cmd_browser = matches.group('browser_type')
         if svn_revision <= 274857 and cmd_browser == 'android-chrome-shell':
           return command_to_run.replace(cmd_browser,
                                         'android-chromium-testshell')
         elif (svn_revision >= 276628 and
               cmd_browser == 'android-chromium-testshell'):
           return command_to_run.replace(cmd_browser,
                                         'android-chrome-shell')
     return command_to_run
 
@@ skipping 25 matching lines @@
           'mean': 0.0,
           'std_err': 0.0,
           'std_dev': 0.0,
           'values': [0.0]
       }
       return (fake_results, success_code)
 
     # For Windows platform set posix=False, to parse windows paths correctly.
     # On Windows, path separators '\' or '\\' are replace by '' when posix=True,
     # refer to http://bugs.python.org/issue1724822. By default posix=True.
-    args = shlex.split(command_to_run, posix=not IsWindowsHost())
+    args = shlex.split(command_to_run, posix=not bisect_utils.IsWindowsHost())
 
     if not self._GenerateProfileIfNecessary(args):
       err_text = 'Failed to generate profile for performance test.'
       return (err_text, failure_code)
 
     # If running a Telemetry test for Chrome OS, insert the remote IP and
     # identity parameters.
     is_telemetry = bisect_utils.IsTelemetryCommand(command_to_run)
     if self.opts.target_platform == 'cros' and is_telemetry:
       args.append('--remote=%s' % self.opts.cros_remote_ip)
       args.append('--identity=%s' % CROS_TEST_KEY_PATH)
 
     start_time = time.time()
 
     metric_values = []
     output_of_all_runs = ''
     for i in xrange(self.opts.repeat_test_count):
       # Can ignore the return code since if the tests fail, it won't return 0.
       current_args = copy.copy(args)
       if is_telemetry:
         if i == 0 and reset_on_first_run:
           current_args.append('--reset-results')
         elif i == self.opts.repeat_test_count - 1 and upload_on_last_run:
           current_args.append('--upload-results')
         if results_label:
           current_args.append('--results-label=%s' % results_label)
       try:
-        (output, return_code) = RunProcessAndRetrieveOutput(current_args,
-                                                            cwd=self.src_cwd)
+        (output, return_code) = bisect_utils.RunProcessAndRetrieveOutput(
+            current_args, cwd=self.src_cwd)
       except OSError, e:
         if e.errno == errno.ENOENT:
           err_text  = ('Something went wrong running the performance test. '
                        'Please review the command line:\n\n')
           if 'src/' in ' '.join(args):
             err_text += ('Check that you haven\'t accidentally specified a '
                          'path with src/ in the command.\n\n')
           err_text += ' '.join(args)
           err_text += '\n'
 
@@ skipping 88 matching lines @@
     # guarantee that the SVN revision will exist for each of the dependant
     # depots, so we have to grep the git logs and grab the next earlier one.
     if not is_base and\
        DEPOT_DEPS_NAME[depot]['depends'] and\
        self.source_control.IsGit():
       svn_rev = self.source_control.SVNFindRev(revision)
 
       for d in DEPOT_DEPS_NAME[depot]['depends']:
         self.ChangeToDepotWorkingDirectory(d)
 
-        dependant_rev = self.source_control.ResolveToRevision(svn_rev, d, -1000)
+        dependant_rev = self.source_control.ResolveToRevision(
+            svn_rev, d, DEPOT_DEPS_NAME, -1000)
 
         if dependant_rev:
           revisions_to_sync.append([d, dependant_rev])
 
       num_resolved = len(revisions_to_sync)
       num_needed = len(DEPOT_DEPS_NAME[depot]['depends'])
 
       self.ChangeToDepotWorkingDirectory(depot)
 
       if not ((num_resolved - 1) == num_needed):
@@ skipping 45 matching lines @@
 
   def PerformCrosChrootCleanup(self):
     """Deletes the chroot.
 
     Returns:
         True if successful.
     """
     cwd = os.getcwd()
     self.ChangeToDepotWorkingDirectory('cros')
     cmd = [CROS_SDK_PATH, '--delete']
-    return_code = RunProcess(cmd)
+    return_code = bisect_utils.RunProcess(cmd)
     os.chdir(cwd)
     return not return_code
 
   def CreateCrosChroot(self):
     """Creates a new chroot.
 
     Returns:
         True if successful.
     """
     cwd = os.getcwd()
     self.ChangeToDepotWorkingDirectory('cros')
     cmd = [CROS_SDK_PATH, '--create']
-    return_code = RunProcess(cmd)
+    return_code = bisect_utils.RunProcess(cmd)
     os.chdir(cwd)
     return not return_code
 
   def PerformPreSyncCleanup(self, revision, depot):
     """Performs any necessary cleanup before syncing.
 
     Returns:
       True if successful.
     """
     if depot == 'chromium' or depot == 'android-chrome':
@@ skipping 39 matching lines @@
     Args:
       depot: The depot being bisected.
       revision: Current revision we're synced to.
 
     Returns:
       True if we should skip building/testing this revision.
     """
     if depot == 'chromium':
       if self.source_control.IsGit():
         cmd = ['diff-tree', '--no-commit-id', '--name-only', '-r', revision]
-        output = CheckRunGit(cmd)
+        output = bisect_utils.CheckRunGit(cmd)
 
         files = output.splitlines()
 
         if len(files) == 1 and files[0] == 'DEPS':
           return True
 
     return False
 
   def SyncBuildAndRunRevision(self, revision, depot, command_to_run, metric,
       skippable=False):
@@ skipping 336 matching lines @@
       if changes_to_deps:
         # DEPS file was changed, search from the oldest change to DEPS file to
         # bad_revision to see if there are matching .DEPS.git changes.
         oldest_deps_change = changes_to_deps[-1]
         changes_to_gitdeps = self.source_control.QueryFileRevisionHistory(
             bisect_utils.FILE_DEPS_GIT, oldest_deps_change, bad_revision)
 
         if len(changes_to_deps) != len(changes_to_gitdeps):
           # Grab the timestamp of the last DEPS change
           cmd = ['log', '--format=%ct', '-1', changes_to_deps[0]]
-          output = CheckRunGit(cmd)
+          output = bisect_utils.CheckRunGit(cmd)
           commit_time = int(output)
 
           # Try looking for a commit that touches the .DEPS.git file in the
           # next 15 minutes after the DEPS file change.
           cmd = ['log', '--format=%H', '-1',
               '--before=%d' % (commit_time + 900), '--after=%d' % commit_time,
               'origin/master', bisect_utils.FILE_DEPS_GIT]
-          output = CheckRunGit(cmd)
+          output = bisect_utils.CheckRunGit(cmd)
           output = output.strip()
           if output:
             self.warnings.append('Detected change to DEPS and modified '
                 'revision range to include change to .DEPS.git')
             return (output, good_revision)
           else:
             self.warnings.append('Detected change to DEPS but couldn\'t find '
                 'matching change to .DEPS.git')
     return (bad_revision, good_revision)
 
   def CheckIfRevisionsInProperOrder(self,
                                     target_depot,
                                     good_revision,
                                     bad_revision):
     """Checks that |good_revision| is an earlier revision than |bad_revision|.
 
     Args:
         good_revision: Number/tag of the known good revision.
         bad_revision: Number/tag of the known bad revision.
 
     Returns:
         True if the revisions are in the proper order (good earlier than bad).
     """
     if self.source_control.IsGit() and target_depot != 'cros':
       cmd = ['log', '--format=%ct', '-1', good_revision]
       cwd = self._GetDepotDirectory(target_depot)
 
-      output = CheckRunGit(cmd, cwd=cwd)
+      output = bisect_utils.CheckRunGit(cmd, cwd=cwd)
       good_commit_time = int(output)
 
       cmd = ['log', '--format=%ct', '-1', bad_revision]
-      output = CheckRunGit(cmd, cwd=cwd)
+      output = bisect_utils.CheckRunGit(cmd, cwd=cwd)
       bad_commit_time = int(output)
 
       return good_commit_time <= bad_commit_time
     else:
       # Cros/svn use integers
       return int(good_revision) <= int(bad_revision)
 
   def CanPerformBisect(self, revision_to_check):
     """Checks whether a given revision is bisectable.
 
     Note: At present it checks whether a given revision is bisectable on
     android bots(refer crbug.com/385324).
 
     Args:
       revision_to_check: Known good revision.
 
     Returns:
       A dictionary indicating the result. If revision is not bisectable,
       this will contain the field "error", otherwise None.
     """
     if self.opts.target_platform == 'android':
       revision_to_check = self.source_control.SVNFindRev(revision_to_check)
-      if IsStringInt(revision_to_check) and revision_to_check < 265549:
+      if (bisect_utils.IsStringInt(revision_to_check)
+          and revision_to_check < 265549):
         return {'error': (
             'Bisect cannot conitnue for the given revision range.\n'
             'It is impossible to bisect Android regressions '
             'prior to r265549, which allows the bisect bot to '
             'rely on Telemetry to do apk installation of the most recently '
             'built local ChromeShell(refer to crbug.com/385324).\n'
             'Please try bisecting revisions greater than or equal to r265549.')}
     return None
 
   def Run(self, command_to_run, bad_revision_in, good_revision_in, metric):
@@ skipping 46 matching lines @@
     target_depot = 'chromium'
     if self.opts.target_platform == 'cros':
       target_depot = 'cros'
     elif self.opts.target_platform == 'android-chrome':
       target_depot = 'android-chrome'
 
     cwd = os.getcwd()
     self.ChangeToDepotWorkingDirectory(target_depot)
 
     # If they passed SVN CL's, etc... we can try match them to git SHA1's.
-    bad_revision = self.source_control.ResolveToRevision(bad_revision_in,
-                                                         target_depot, 100)
-    good_revision = self.source_control.ResolveToRevision(good_revision_in,
-                                                          target_depot, -100)
+    bad_revision = self.source_control.ResolveToRevision(
+        bad_revision_in, target_depot, DEPOT_DEPS_NAME, 100)
+    good_revision = self.source_control.ResolveToRevision(
+        good_revision_in, target_depot, DEPOT_DEPS_NAME, -100)
 
     os.chdir(cwd)
 
 
     if bad_revision is None:
       results['error'] = 'Could\'t resolve [%s] to SHA1.' % (bad_revision_in,)
       return results
 
     if good_revision is None:
       results['error'] = 'Could\'t resolve [%s] to SHA1.' % (good_revision_in,)
@@ skipping 571 matching lines @@
       cwd = os.getcwd()
       self.ChangeToDepotWorkingDirectory(
           revision_data[last_broken_revision]['depot'])
 
       if revision_data[last_broken_revision]['depot'] == 'cros':
         # Want to get a list of all the commits and what depots they belong
         # to so that we can grab info about each.
         cmd = ['repo', 'forall', '-c',
             'pwd ; git log --pretty=oneline --before=%d --after=%d' % (
             last_broken_revision, first_working_revision + 1)]
-        (output, return_code) = RunProcessAndRetrieveOutput(cmd)
+        (output, return_code) = bisect_utils.RunProcessAndRetrieveOutput(cmd)
 
         changes = []
         assert not return_code, 'An error occurred while running'\
                                 ' "%s"' % ' '.join(cmd)
         last_depot = None
         cwd = os.getcwd()
         for l in output.split('\n'):
           if l:
             # Output will be in form:
             # /path_to_depot
@@ skipping 107 matching lines @@
                                   results_dict['first_working_revision'],
                                   results_dict['last_broken_revision'],
                                   results_dict['confidence'])
     self._PrintStepTime(revision_data_sorted)
     self._PrintReproSteps()
     self._PrintThankYou()
     if self.opts.output_buildbot_annotations:
       bisect_utils.OutputAnnotationStepClosed()
 
 
-def DetermineAndCreateSourceControl(opts):
-  """Attempts to determine the underlying source control workflow and returns
-  a SourceControl object.
-
-  Returns:
-    An instance of a SourceControl object, or None if the current workflow
-    is unsupported.
-  """
-
-  (output, _) = RunGit(['rev-parse', '--is-inside-work-tree'])
-
-  if output.strip() == 'true':
-    return GitSourceControl(opts)
-
-  return None
-
-
 def IsPlatformSupported(opts):
   """Checks that this platform and build system are supported.
 
   Args:
     opts: The options parsed from the command line.
 
   Returns:
     True if the platform and build system are supported.
   """
   # Haven't tested the script out on any other platforms yet.
@@ skipping 243 matching lines @@
         if not opts.builder_host:
           raise RuntimeError('Must specify try server hostname, when '
                              'gs_bucket is used: --builder_host')
         if not opts.builder_port:
           raise RuntimeError('Must specify try server port number, when '
                              'gs_bucket is used: --builder_port')
       if opts.target_platform == 'cros':
         # Run sudo up front to make sure credentials are cached for later.
         print 'Sudo is required to build cros:'
         print
-        RunProcess(['sudo', 'true'])
+        bisect_utils.RunProcess(['sudo', 'true'])
 
         if not opts.cros_board:
           raise RuntimeError('missing required parameter: --cros_board')
 
         if not opts.cros_remote_ip:
           raise RuntimeError('missing required parameter: --cros_remote_ip')
 
         if not opts.working_directory:
           raise RuntimeError('missing required parameter: --working_directory')
 
@@ skipping 67 matching lines @@
       bisect_utils.CreateBisectDirectoryAndSetupDepot(opts, custom_deps)
 
       os.chdir(os.path.join(os.getcwd(), 'src'))
 
       if not RemoveBuildFiles(opts.target_build_type):
         raise RuntimeError('Something went wrong removing the build files.')
 
     if not IsPlatformSupported(opts):
       raise RuntimeError("Sorry, this platform isn't supported yet.")
 
-    # Check what source control method they're using. Only support git workflow
-    # at the moment.
-    source_control = DetermineAndCreateSourceControl(opts)
+    # Check what source control method is being used, and create a
+    # SourceControl object if possible.
+    source_control = source_control_module.DetermineAndCreateSourceControl(opts)
 
     if not source_control:
       raise RuntimeError("Sorry, only the git workflow is supported at the "
           "moment.")
 
     # gClient sync seems to fail if you're not in master branch.
     if (not source_control.IsInProperBranch() and
         not opts.debug_ignore_sync and
         not opts.working_directory):
       raise RuntimeError("You must switch to master branch to run bisection.")
@@ skipping 14 matching lines @@
       # The perf dashboard scrapes the "results" step in order to comment on
       # bugs. If you change this, please update the perf dashboard as well.
       bisect_utils.OutputAnnotationStepStart('Results')
     print 'Error: %s' % e.message
     if opts.output_buildbot_annotations:
       bisect_utils.OutputAnnotationStepClosed()
   return 1
 
 if __name__ == '__main__':
   sys.exit(main())