Update bisect script to handle deleted .DEPS.git from chromium source

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 1049 matching lines @@
       depot: Name of depot being bisected.
 
     Returns:
       A dict in the format {depot:revision} if successful, otherwise None.
     """
     try:
       deps_data = {
           'Var': lambda _: deps_data["vars"][_],
           'From': lambda *args: None,
       }
-      execfile(bisect_utils.FILE_DEPS_GIT, {}, deps_data)
+
+      deps_file = bisect_utils.FILE_DEPS_GIT
+      if not os.path.exists(deps_file):
+        deps_file = bisect_utils.FILE_DEPS
+      execfile(deps_file, {}, deps_data)
       deps_data = deps_data['deps']
 
       rxp = re.compile(".git@(?P<revision>[a-fA-F0-9]+)")
       results = {}
       for depot_name, depot_data in DEPOT_DEPS_NAME.iteritems():
         if (depot_data.get('platform') and
             depot_data.get('platform') != os.name):
           continue
 
         if (depot_data.get('recurse') and depot in depot_data.get('from')):
           depot_data_src = depot_data.get('src') or depot_data.get('src_old')
           src_dir = deps_data.get(depot_data_src)
           if src_dir:
             self.depot_cwd[depot_name] = os.path.join(self.src_cwd,
                                                       depot_data_src[4:])
             re_results = rxp.search(src_dir)
             if re_results:
               results[depot_name] = re_results.group('revision')
             else:
               warning_text = ('Could not parse revision for %s while bisecting '
                               '%s' % (depot_name, depot))
               if not warning_text in self.warnings:
                 self.warnings.append(warning_text)
           else:
             results[depot_name] = None
       return results
     except ImportError:
-      deps_file_contents = ReadStringFromFile(bisect_utils.FILE_DEPS_GIT)
+      deps_file_contents = ReadStringFromFile(deps_file)
       parse_results = _ParseRevisionsFromDEPSFileManually(deps_file_contents)
       results = {}
       for depot_name, depot_revision in parse_results.iteritems():
         depot_revision = depot_revision.strip('@')
         print depot_name, depot_revision
         for current_name, current_data in DEPOT_DEPS_NAME.iteritems():
           if (current_data.has_key('deps_var') and
               current_data['deps_var'] == depot_name):
             src_name = current_name
             results[src_name] = depot_revision
@@ skipping 661 matching lines @@
   def PerformWebkitDirectoryCleanup(self, revision):
     """Cleans up the Webkit directory before syncing another revision.
 
     If the script is switching between Blink and WebKit during bisect,
     its faster to just delete the directory rather than leave it up to git
     to sync.
 
     Returns:
       True if successful.
     """
-    if not self.source_control.CheckoutFileAtRevision(
-        bisect_utils.FILE_DEPS_GIT, revision, cwd=self.src_cwd):
-      return False
-
     cwd = os.getcwd()
     os.chdir(self.src_cwd)
 
-    is_blink = bisect_utils.IsDepsFileBlink()
+    is_blink = bisect_utils.IsDepsFileBlink(revision)
 
     os.chdir(cwd)
 
-    if not self.source_control.RevertFileToHead(
-        bisect_utils.FILE_DEPS_GIT):
-      return False
-
     if self.was_blink != is_blink:
       self.was_blink = is_blink
       # Removes third_party/Webkit directory.
       return bisect_utils.RemoveThirdPartyDirectory('Webkit')
     return True
 
   def PerformCrosChrootCleanup(self):
     """Deletes the chroot.
 
     Returns:
@@ skipping 363 matching lines @@
 
     print
     print 'Revisions to bisect on [%s]:' % depot
     for revision_id in revision_list:
       print '  -> %s' % (revision_id, )
     print
 
     if self.opts.output_buildbot_annotations:
       bisect_utils.OutputAnnotationStepClosed()
 
-  def NudgeRevisionsIfDEPSChange(self, bad_revision, good_revision):
+  def NudgeRevisionsIfDEPSChange(self, bad_revision, good_revision,
+                                 good_svn_revision=None):
     """Checks to see if changes to DEPS file occurred, and that the revision
     range also includes the change to .DEPS.git. If it doesn't, attempts to
     expand the revision range to include it.
 
     Args:
-      bad_rev: First known bad revision.
-      good_revision: Last known good revision.
+      bad_revision: First known bad git revision.
+      good_revision: Last known good git revision.
+      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(
           '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(
             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.
           cmd = ['log', '--format=%H', '-1',
               '--before=%d' % (commit_time + 900), '--after=%d' % commit_time,
-              'origin/master', bisect_utils.FILE_DEPS_GIT]
+              'origin/master', '--', bisect_utils.FILE_DEPS_GIT]
           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)
@@ skipping 109 matching lines @@
     cwd = os.getcwd()
     self.ChangeToDepotWorkingDirectory(target_depot)
 
     # If they passed SVN revisions, we can try match them to git SHA1 hashes.
     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'] = '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
 
     # Check that they didn't accidentally swap good and bad revisions.
     if not self.CheckIfRevisionsInProperOrder(
         target_depot, good_revision, bad_revision):
       results['error'] = ('bad_revision < good_revision, did you swap these '
                           'by mistake?')
       return results
-
     bad_revision, good_revision = self.NudgeRevisionsIfDEPSChange(
-        bad_revision, good_revision)
-
+        bad_revision, good_revision, good_revision_in)
     if self.opts.output_buildbot_annotations:
       bisect_utils.OutputAnnotationStepStart('Gathering Revisions')
 
     cannot_bisect = self.CanPerformBisect(good_revision)
     if cannot_bisect:
       results['error'] = cannot_bisect.get('error')
       return results
 
     print 'Gathering revision range for bisection.'
     # Retrieve a list of revisions to do bisection on.
@@ skipping 992 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())