Replace "git svn" with "git footers" commands to get commit position or svn revision.

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 957 matching lines @@
           [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)
+    commit_position = self.source_control.GetCommitPosition(revision)
 
-    if bisect_utils.IsStringInt(svn_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.
@@ skipping 19 matching lines @@
             git_revision = self.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(
-              int(svn_revision) - 1, 'v8_bleeding_edge', DEPOT_DEPS_NAME, -1,
+              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,
                 cwd=v8_bleeding_edge_dir)
 
             if 'Prepare push to trunk' in revision_info['subject']:
               return git_revision
     return None
 
@@ skipping 193 matching lines @@
       out_dir: Build output directory where downloaded file is stored.
 
     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 SVN revision for the given SHA.
-      svn_revision = self.source_control.SVNFindRev(revision)
-      if svn_revision:
+      # Get commit position for the given SHA.
+      commit_position = self.source_control.GetCommitPosition(revision)
+      if commit_position:
         # Source archive file path on cloud storage using SVN revision.
         source_file = GetRemoteBuildPath(
-            svn_revision, self.opts.target_platform, target_arch, patch_sha)
+            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, build_type='Release', patch=None):
     """Downloads the build archive for the given revision.
 
     Args:
       revision: The Git revision to download or build.
       build_type: Target build type ('Release', 'Debug', 'Release_x64' etc.)
       patch: A DEPS patch (used while bisecting 3rd party repositories).
@@ skipping 150 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):
-      svn_revision = self.source_control.SVNFindRev(
+      commit_position = self.source_control.GetCommitPosition(
           git_revision, self._GetDepotDirectory(depot))
-      if not svn_revision:
-        print 'Could not determine SVN revision for %s' % git_revision
+      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(svn_revision), deps_contents)
+      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(
           r'(?<=["\']%s["\']: ["\'])([a-fA-F0-9]{40})(?=["\'])' % deps_key,
           re.MULTILINE)
       if re.search(deps_revision, deps_contents):
         new_data = re.sub(deps_revision, git_revision, deps_contents)
     if new_data:
       # For v8_bleeding_edge revisions change V8 branch in order
@@ skipping 144 matching lines @@
     # 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-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()
-      svn_revision = self.source_control.SVNFindRev(revision, cwd=self.src_cwd)
-      if not svn_revision:
+      commit_position = self.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(svn_revision) and matches:
+      if bisect_utils.IsStringInt(commit_position) and matches:
         cmd_browser = matches.group('browser_type')
-        if svn_revision <= 274857 and cmd_browser == 'android-chrome-shell':
+        if commit_position <= 274857 and cmd_browser == 'android-chrome-shell':
           return command_to_run.replace(cmd_browser,
                                         'android-chromium-testshell')
-        elif (svn_revision >= 276628 and
+        elif (commit_position >= 276628 and
               cmd_browser == 'android-chromium-testshell'):
           return command_to_run.replace(cmd_browser,
                                         'android-chrome-shell')
     return command_to_run
 
   def RunPerformanceTestAndParseResults(
       self, command_to_run, metric, reset_on_first_run=False,
       upload_on_last_run=False, results_label=None):
     """Runs a performance test on the current revision and parses the results.
 
@@ skipping 156 matching lines @@
     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()):
-      svn_rev = self.source_control.SVNFindRev(revision)
+      commit_position = self.source_control.GetCommitPosition(revision)
 
       for d in DEPOT_DEPS_NAME[depot]['depends']:
         self.ChangeToDepotWorkingDirectory(d)
 
         dependant_rev = self.source_control.ResolveToRevision(
-            svn_rev, d, DEPOT_DEPS_NAME, -1000)
+            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.ChangeToDepotWorkingDirectory(depot)
 
       if not ((num_resolved - 1) == num_needed):
@@ skipping 491 matching lines @@
 
     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':
-      revision_to_check = self.source_control.SVNFindRev(good_revision)
+      revision_to_check = self.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.SVNFindRev(good_revision)
-      bad_revision = self.source_control.SVNFindRev(bad_revision)
+      good_revision = self.source_control.GetCommitPosition(good_revision)
+      bad_revision = self.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
 
@@ skipping 1087 matching lines @@
       # 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())