Refactor source_control.py and add a test.

tools/auto_bisect/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 36 matching lines @@
 import zipfile
 
 sys.path.append(os.path.join(
     os.path.dirname(__file__), os.path.pardir, 'telemetry'))
 
 from bisect_results import BisectResults
 import bisect_utils
 import builder
 import math_utils
 import request_build
-import source_control as source_control_module
+import source_control
 from telemetry.util import cloud_storage
 
 # Below is the map of "depot" names to information about each depot. Each depot
 # is a repository, and in the process of bisecting, revision ranges in these
 # repositories may also be bisected.
 #
 # Each depot information dictionary may contain:
 #   src: Path to the working directory.
 #   recurse: True if this repository will get bisected.
 #   depends: A list of other repositories that are actually part of the same
@@ skipping 882 matching lines @@
     bisect_utils.RunGit(['branch', '-D', BISECT_TRYJOB_BRANCH])
 
 
 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):
+  def __init__(self, opts):
     super(BisectPerformanceMetrics, self).__init__()
 
     self.opts = opts
-    self.source_control = source_control
 
     # The src directory here is NOT the src/ directory for the repository
     # where the bisect script is running from. Instead, it's the src/ directory
     # inside the bisect/ directory which is created before running.
     self.src_cwd = os.getcwd()
 
     self.depot_registry = DepotDirectoryRegistry(self.src_cwd)
     self.cleanup_commands = []
     self.warnings = []
     self.builder = builder.Builder.FromOpts(opts)
@@ skipping 32 matching lines @@
       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 bisect_utils.IsStringInt(o)]))
       revision_work_list = sorted(revision_work_list, reverse=True)
     else:
       cwd = self.depot_registry.GetDepotDir(depot)
-      revision_work_list = self.source_control.GetRevisionList(bad_revision,
+      revision_work_list = source_control.GetRevisionList(bad_revision,
           good_revision, cwd=cwd)
 
     return revision_work_list
 
   def _GetV8BleedingEdgeFromV8TrunkIfMappable(self, revision):
-    commit_position = self.source_control.GetCommitPosition(revision)
+    commit_position = source_control.GetCommitPosition(revision)
 
     if bisect_utils.IsStringInt(commit_position):
       # 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.
       v8_dir = self.depot_registry.GetDepotDir('v8')
       v8_bleeding_edge_dir = self.depot_registry.GetDepotDir('v8_bleeding_edge')
 
-      revision_info = self.source_control.QueryRevisionInfo(revision,
-          cwd=v8_dir)
+      revision_info = source_control.QueryRevisionInfo(revision, cwd=v8_dir)
 
       version_re = re.compile("Version (?P<values>[0-9,.]+)")
 
       regex_results = version_re.search(revision_info['subject'])
 
       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(
+            git_revision = source_control.ResolveToRevision(
                 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(
+          git_revision = source_control.ResolveToRevision(
               int(commit_position) - 1, 'v8_bleeding_edge', DEPOT_DEPS_NAME, -1,
               cwd=v8_bleeding_edge_dir)
 
           if git_revision:
-            revision_info = self.source_control.QueryRevisionInfo(git_revision,
+            revision_info = 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.depot_registry.GetDepotDir('v8')
     cmd = ['log', '--format=%ct', '-1', revision]
     output = bisect_utils.CheckRunGit(cmd, cwd=cwd)
@@ skipping 190 matching lines @@
 
     Returns:
       Downloaded archive file path if exists, otherwise None.
     """
     # Source archive file path on cloud storage using Git revision.
     source_file = GetRemoteBuildPath(
         revision, self.opts.target_platform, target_arch, patch_sha)
     downloaded_archive = FetchFromCloudStorage(gs_bucket, source_file, out_dir)
     if not downloaded_archive:
       # Get commit position for the given SHA.
-      commit_position = self.source_control.GetCommitPosition(revision)
+      commit_position = source_control.GetCommitPosition(revision)
       if commit_position:
         # Source archive file path on cloud storage using SVN revision.
         source_file = GetRemoteBuildPath(
             commit_position, self.opts.target_platform, target_arch, patch_sha)
         return FetchFromCloudStorage(gs_bucket, source_file, out_dir)
     return downloaded_archive
 
   def DownloadCurrentBuild(self, revision, depot, build_type='Release'):
     """Downloads the build archive for the given revision.
 
@@ skipping 107 matching lines @@
       raise NotImplementedError('Unsupported Platform "%s".' % sys.platform)
     if not fetch_build:
       return False
 
     # Create a unique ID for each build request posted to try server builders.
     # This ID is added to "Reason" property of the build.
     build_request_id = GetSHA1HexDigest(
         '%s-%s-%s' % (git_revision, patch, time.time()))
 
     # Reverts any changes to DEPS file.
-    self.source_control.CheckoutFileAtRevision(
+    source_control.CheckoutFileAtRevision(
       bisect_utils.FILE_DEPS, git_revision, cwd=self.src_cwd)
 
     bot_name, build_timeout = GetBuilderNameAndBuildTime(
        self.opts.target_platform, self.opts.target_arch)
     target_file = None
     try:
       # Execute try job request to build revision with patch.
       _BuilderTryjob(git_revision, bot_name, build_request_id, patch)
       target_file, error_msg = _WaitUntilBuildIsReady(
           fetch_build, bot_name, self.opts.builder_host,
@@ skipping 26 matching lines @@
 
     Returns:
       Updated DEPS content as string if deps key is found, otherwise None.
     """
     # Check whether the depot and revision pattern in DEPS file vars
     # e.g. for webkit the format is "webkit_revision": "12345".
     deps_revision = re.compile(r'(?<="%s": ")([0-9]+)(?=")' % deps_key,
                                re.MULTILINE)
     new_data = None
     if re.search(deps_revision, deps_contents):
-      commit_position = self.source_control.GetCommitPosition(
+      commit_position = source_control.GetCommitPosition(
           git_revision, self.depot_registry.GetDepotDir(depot))
       if not commit_position:
         print 'Could not determine commit position for %s' % git_revision
         return None
       # Update the revision information for the given depot
       new_data = re.sub(deps_revision, str(commit_position), deps_contents)
     else:
       # Check whether the depot and revision pattern in DEPS file vars
       # e.g. for webkit the format is "webkit_revision": "559a6d4ab7a84c539..".
       deps_revision = re.compile(
@@ skipping 70 matching lines @@
       raise RuntimeError('DEPS file does not exists.[%s]' % deps_file_path)
     # Get current chromium revision (git hash).
     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(
+      if 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=',
               '--dst-prefix=',
               '--no-ext-diff',
                bisect_utils.FILE_DEPS,
           ]
           diff_text = bisect_utils.CheckRunGit(diff_command, cwd=self.src_cwd)
@@ skipping 54 matching lines @@
     Then until crrev.com/276628 *both* (android-chromium-testshell and
     android-chrome-shell) work. After that rev 276628 *only*
     android-chrome-shell works. The bisect_perf_regression.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 = bisect_utils.CheckRunGit(
             ['rev-parse', 'HEAD'], cwd=self.src_cwd).strip()
-      commit_position = self.source_control.GetCommitPosition(revision,
-                                                              cwd=self.src_cwd)
+      commit_position = source_control.GetCommitPosition(revision,
+                                                         cwd=self.src_cwd)
       if not commit_position:
         return command_to_run
       cmd_re = re.compile('--browser=(?P<browser_type>\S+)')
       matches = cmd_re.search(command_to_run)
       if bisect_utils.IsStringInt(commit_position) and matches:
         cmd_browser = matches.group('browser_type')
         if commit_position <= 274857 and cmd_browser == 'android-chrome-shell':
           return command_to_run.replace(cmd_browser,
                                         'android-chromium-testshell')
         elif (commit_position >= 276628 and
@@ skipping 163 matching lines @@
     """
     revisions_to_sync = [[depot, revision]]
 
     is_base = ((depot == 'chromium') or (depot == 'cros') or
         (depot == 'android-chrome'))
 
     # Some SVN depots were split into multiple git depots, so we need to
     # figure out for each mirror which git revision to grab. There's no
     # guarantee that the SVN revision will exist for each of the dependent
     # 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()):
-      commit_position = self.source_control.GetCommitPosition(revision)
+    if not is_base and DEPOT_DEPS_NAME[depot]['depends']:
+      commit_position = source_control.GetCommitPosition(revision)
 
       for d in DEPOT_DEPS_NAME[depot]['depends']:
         self.depot_registry.ChangeToDepotDir(d)
 
-        dependant_rev = self.source_control.ResolveToRevision(
+        dependant_rev = source_control.ResolveToRevision(
             commit_position, 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.depot_registry.ChangeToDepotDir(depot)
 
@@ skipping 66 matching lines @@
       if not builder.SetupAndroidBuildEnvironment(self.opts,
           path_to_src=self.src_cwd):
         return False
 
     if depot == 'cros':
       return self.CreateCrosChroot()
     else:
       return self.RunGClientHooks()
     return True
 
-  def ShouldSkipRevision(self, depot, revision):
+  @staticmethod
+  def ShouldSkipRevision(depot, revision):
     """Checks whether a particular revision can be safely skipped.
 
     Some commits can be safely skipped (such as a DEPS roll), since the tool
     is git based those changes would have no effect.
 
     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 = bisect_utils.CheckRunGit(cmd)
+      cmd = ['diff-tree', '--no-commit-id', '--name-only', '-r', revision]
+      output = bisect_utils.CheckRunGit(cmd)
 
-        files = output.splitlines()
+      files = output.splitlines()
 
-        if len(files) == 1 and files[0] == 'DEPS':
-          return True
+      if len(files) == 1 and files[0] == 'DEPS':
+        return True
 
     return False
 
   def RunTest(self, revision, depot, command, metric, skippable=False):
     """Performs a full sync/build/run of the specified revision.
 
     Args:
       revision: The revision to sync to.
       depot: The depot that's being used at the moment (src, webkit, etc.)
       command: The command to execute the performance test.
@@ skipping 82 matching lines @@
 
       if sync_client:
         self.PerformPreBuildCleanup()
 
       # When using gclient to sync, you need to specify the depot you
       # want so that all the dependencies sync properly as well.
       # i.e. gclient sync src@<SHA1>
       if sync_client == 'gclient':
         revision = '%s@%s' % (DEPOT_DEPS_NAME[depot]['src'], revision)
 
-      sync_success = self.source_control.SyncToRevision(revision, sync_client)
+      sync_success = source_control.SyncToRevision(revision, sync_client)
       if not sync_success:
         return False
 
     return True
 
   def _CheckIfRunPassed(self, current_value, known_good_value, known_bad_value):
     """Given known good and bad values, decide if the current_value passed
     or failed.
 
     Args:
@@ skipping 177 matching lines @@
       good_svn_revision: Last known good svn revision.
 
     Returns:
       A tuple with the new bad and good revisions.
     """
     # DONOT perform nudge because at revision 291563 .DEPS.git was removed
     # and source contain only DEPS file for dependency changes.
     if good_svn_revision >= 291563:
       return (bad_revision, good_revision)
 
-    if self.source_control.IsGit() and self.opts.target_platform == 'chromium':
-      changes_to_deps = self.source_control.QueryFileRevisionHistory(
+    if self.opts.target_platform == 'chromium':
+      changes_to_deps = source_control.QueryFileRevisionHistory(
           bisect_utils.FILE_DEPS, good_revision, bad_revision)
 
       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(
+        changes_to_gitdeps = 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 = 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.
@@ skipping 15 matching lines @@
       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':
+    if target_depot != 'cros':
       cwd = self.depot_registry.GetDepotDir(target_depot)
-      good_position = self.source_control.GetCommitPosition(good_revision, cwd)
-      bad_position = self.source_control.GetCommitPosition(bad_revision, cwd)
+      good_position = source_control.GetCommitPosition(good_revision, cwd)
+      bad_position = source_control.GetCommitPosition(bad_revision, cwd)
     else:
       # CrOS and SVN use integers.
       good_position = int(good_revision)
       bad_position = int(bad_revision)
 
     return good_position <= bad_position
 
   def CanPerformBisect(self, good_revision, bad_revision):
     """Checks whether a given revision is bisectable.
 
     Checks for following:
     1. Non-bisectable revsions for android bots (refer to crbug.com/385324).
     2. Non-bisectable revsions for Windows bots (refer to crbug.com/405274).
 
     Args:
       good_revision: Known good revision.
       bad_revision: Known bad 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':
-      good_revision = self.source_control.GetCommitPosition(good_revision)
+      good_revision = source_control.GetCommitPosition(good_revision)
       if (bisect_utils.IsStringInt(good_revision)
           and good_revision < 265549):
         return {'error': (
             'Bisect cannot continue 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.')}
 
     if bisect_utils.IsWindowsHost():
-      good_revision = self.source_control.GetCommitPosition(good_revision)
-      bad_revision = self.source_control.GetCommitPosition(bad_revision)
+      good_revision = source_control.GetCommitPosition(good_revision)
+      bad_revision = source_control.GetCommitPosition(bad_revision)
       if (bisect_utils.IsStringInt(good_revision) and
           bisect_utils.IsStringInt(bad_revision)):
         if (289987 <= good_revision < 290716 or
             289987 <= bad_revision < 290716):
           return {'error': ('Oops! Revision between r289987 and r290716 are '
                             'marked as dead zone for Windows due to '
                             'crbug.com/405274. Please try another range.')}
 
     return None
 
   def Run(self, command_to_run, bad_revision_in, good_revision_in, metric):
     """Given known good and bad revisions, run a binary search on all
     intermediate revisions to determine the CL where the performance regression
     occurred.
 
     Args:
       command_to_run: Specify the command to execute the performance test.
       good_revision: Number/tag of the known good revision.
       bad_revision: Number/tag of the known bad revision.
       metric: The performance metric to monitor.
 
     Returns:
       A BisectResults object.
     """
-    results = BisectResults(self.depot_registry, self.source_control)
+    results = BisectResults(self.depot_registry)
 
     # Choose depot to bisect first
     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.depot_registry.ChangeToDepotDir(target_depot)
 
     # If they passed SVN revisions, we can try match them to git SHA1 hashes.
-    bad_revision = self.source_control.ResolveToRevision(
+    bad_revision = source_control.ResolveToRevision(
         bad_revision_in, target_depot, DEPOT_DEPS_NAME, 100)
-    good_revision = self.source_control.ResolveToRevision(
+    good_revision = source_control.ResolveToRevision(
         good_revision_in, target_depot, DEPOT_DEPS_NAME, -100)
 
     os.chdir(cwd)
     if bad_revision is None:
       results.error = 'Couldn\'t resolve [%s] to SHA1.' % bad_revision_in
       return results
 
     if good_revision is None:
       results.error = 'Couldn\'t resolve [%s] to SHA1.' % good_revision_in
       return results
@@ skipping 245 matching lines @@
       level = 'high'
     else:
       level = 'low'
     warning = ' and warnings'
     if not self.warnings:
       warning = ''
     return confidence_status % {'level': level, 'warning': warning}
 
   def _GetViewVCLinkFromDepotAndHash(self, revision_id, depot):
     """Gets link to the repository browser."""
-    info = self.source_control.QueryRevisionInfo(revision_id,
+    info = source_control.QueryRevisionInfo(revision_id,
         self.depot_registry.GetDepotDir(depot))
     if depot and DEPOT_DEPS_NAME[depot].has_key('viewvc'):
       try:
         # Format is "git-svn-id: svn://....@123456 <other data>"
         svn_line = [i for i in info['body'].splitlines() if 'git-svn-id:' in i]
         svn_revision = svn_line[0].split('@')
         svn_revision = svn_revision[1].split(' ')[0]
         return DEPOT_DEPS_NAME[depot]['viewvc'] + svn_revision
       except IndexError:
         return ''
@@ skipping 88 matching lines @@
 
         # If confidence is too low, don't bother outputting good/bad.
         if not confidence:
           state_str = ''
         state_str = state_str.center(13, ' ')
 
         cl_link = self._GetViewVCLinkFromDepotAndHash(current_id,
             current_data['depot'])
         if not cl_link:
           cl_link = current_id
-        commit_position = self.source_control.GetCommitPosition(
+        commit_position = source_control.GetCommitPosition(
             current_id, self.depot_registry.GetDepotDir(current_data['depot']))
         commit_position = str(commit_position)
         if not commit_position:
           commit_position = ''
         self._PrintTestedCommitsEntry(current_data, commit_position, cl_link,
                                       state_str)
 
   def _PrintReproSteps(self):
     """Prints out a section of the results explaining how to run the test.
 
@@ skipping 483 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():
       raise RuntimeError('Sorry, this platform isn\'t supported yet.')
 
-    # 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:
+    if not source_control.IsInGitRepository():
       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.')
-    bisect_test = BisectPerformanceMetrics(source_control, opts)
+    bisect_test = BisectPerformanceMetrics(opts)
     try:
       bisect_results = bisect_test.Run(opts.command,
                                        opts.bad_revision,
                                        opts.good_revision,
                                        opts.metric)
       if bisect_results.error:
         raise RuntimeError(bisect_results.error)
       bisect_test.FormatAndPrintResults(bisect_results)
       return 0
     finally:
       bisect_test.PerformCleanup()
   except RuntimeError, e:
     if opts.output_buildbot_annotations:
       # 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())