Skip syncing V8_bleeding_edge unless bisecting V8.

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 62 matching lines @@
     "src" : "src/third_party/WebKit",
     "recurse" : True,
     "depends" : None,
     "from" : 'chromium'
   },
   'v8' : {
     "src" : "src/v8",
     "recurse" : True,
     "depends" : None,
     "build_with": 'v8_bleeding_edge',
-    "from" : 'chromium'
+    "from" : 'chromium',
+    "custom_deps": bisect_utils.GCLIENT_CUSTOM_DEPS_V8
   },
   'v8_bleeding_edge' : {
     "src" : "src/v8_bleeding_edge",
     "recurse" : False,
     "depends" : None,
     "svn": "https://v8.googlecode.com/svn/branches/bleeding_edge",
     "from" : 'chromium'
   },
   'skia/src' : {
     "src" : "src/third_party/skia/src",
@@ skipping 1225 matching lines @@
     elif depot_name in DEPOT_NAMES:
       os.chdir(self.depot_cwd[depot_name])
     else:
       assert False, 'Unknown depot [ %s ] encountered. Possibly a new one'\
                     ' was added without proper support?' %\
                     (depot_name,)
 
   def PrepareToBisectOnDepot(self,
                              current_depot,
                              end_revision,
-                             start_revision):
+                             start_revision,
+                             previous_depot,
+                             previous_revision):
     """Changes to the appropriate directory and gathers a list of revisions
     to bisect between |start_revision| and |end_revision|.
 
     Args:
       current_depot: The depot we want to bisect.
       end_revision: End of the revision range.
       start_revision: Start of the revision range.
+      previous_depot: The depot we were previously bisecting.
+      previous_revision: The last revision we synced to on |previous_depot|.
 
     Returns:
       A list containing the revisions between |start_revision| and
       |end_revision| inclusive.
     """
     # Change into working directory of external library to run
     # subsequent commands.
     old_cwd = os.getcwd()
     os.chdir(self.depot_cwd[current_depot])
 
     # V8 (and possibly others) is merged in periodically. Bisecting
     # this directory directly won't give much good info.
     if DEPOT_DEPS_NAME[current_depot].has_key('build_with'):
+      if DEPOT_DEPS_NAME[current_depot].has_key('custom_deps') and\

[tonyg, 2013/06/21 16:38:00]

Nit: Please use parens instead of \

+          previous_depot == 'chromium':
+        config_path = os.path.join(self.src_cwd, '..')
+        if bisect_utils.RunGClientAndCreateConfig(self.opts,
+            DEPOT_DEPS_NAME[current_depot]['custom_deps'], cwd=config_path):
+          return []
+        if bisect_utils.RunGClient(
+            ['sync', '--revision', previous_revision], cwd=self.src_cwd):
+          return []
+
       new_depot = DEPOT_DEPS_NAME[current_depot]['build_with']
 
       svn_start_revision = self.source_control.SVNFindRev(start_revision)
       svn_end_revision = self.source_control.SVNFindRev(end_revision)
       os.chdir(self.depot_cwd[new_depot])
 
       start_revision = self.source_control.ResolveToRevision(
           svn_start_revision, new_depot, -1000)
       end_revision = self.source_control.ResolveToRevision(
           svn_end_revision, new_depot, -1000)
@@ skipping 284 matching lines @@
       bad_revision_data = revision_data[revision_list[0]]
       bad_revision_data['external'] = bad_results[2]
       bad_revision_data['passed'] = 0
       bad_revision_data['value'] = known_bad_value
 
       good_revision_data = revision_data[revision_list[max_revision]]
       good_revision_data['external'] = good_results[2]
       good_revision_data['passed'] = 1
       good_revision_data['value'] = known_good_value
 
+      next_revision_depot = target_depot
+
       while True:
         if not revision_list:
           break
 
         min_revision_data = revision_data[revision_list[min_revision]]
         max_revision_data = revision_data[revision_list[max_revision]]
 
         if max_revision - min_revision <= 1:
           if min_revision_data['passed'] == '?':
             next_revision_index = min_revision
           elif max_revision_data['passed'] == '?':
             next_revision_index = max_revision
           elif min_revision_data['depot'] == 'chromium' or\
                min_revision_data['depot'] == 'cros':
             # If there were changes to any of the external libraries we track,
             # should bisect the changes there as well.
             external_depot = None
 
             for current_depot in DEPOT_NAMES:
               if DEPOT_DEPS_NAME[current_depot]["recurse"] and\
                  DEPOT_DEPS_NAME[current_depot]['from'] ==\
                  min_revision_data['depot']:
                 if min_revision_data['external'][current_depot] !=\
                    max_revision_data['external'][current_depot]:
                   external_depot = current_depot
-
                   break
 
             # If there was no change in any of the external depots, the search
             # is over.
             if not external_depot:
               break
 
-            earliest_revision = max_revision_data['external'][current_depot]
-            latest_revision = min_revision_data['external'][current_depot]
+            previous_revision = revision_list[min_revision]
+
+            earliest_revision = max_revision_data['external'][external_depot]
+            latest_revision = min_revision_data['external'][external_depot]
 
             new_revision_list = self.PrepareToBisectOnDepot(external_depot,
                                                             latest_revision,
-                                                            earliest_revision)
+                                                            earliest_revision,
+                                                            next_revision_depot,
+                                                            previous_revision)
 
             if not new_revision_list:
               results['error'] = 'An error occurred attempting to retrieve'\
                                  ' revision range: [%s..%s]' %\
                                  (depot_rev_range[1], depot_rev_range[0])
               return results
 
             self.AddRevisionsIntoRevisionData(new_revision_list,
                                               external_depot,
                                               min_revision_data['sort'],
                                               revision_data)
 
             # Reset the bisection and perform it on the newly inserted
             # changelists.
             revision_list = new_revision_list
             min_revision = 0
             max_revision = len(revision_list) - 1
             sort_key_ids += len(revision_list)
 
             print 'Regression in metric:%s appears to be the result of changes'\
-                  ' in [%s].' % (metric, current_depot)
+                  ' in [%s].' % (metric, external_depot)
 
             self.PrintRevisionsToBisectMessage(revision_list, external_depot)
 
             continue
           else:
             break
         else:
           next_revision_index = int((max_revision - min_revision) / 2) +\
                                 min_revision
 
@@ skipping 574 matching lines @@
 
   if not(bisect_results['error']):
     return 0
   else:
     print 'Error: ' + bisect_results['error']
     print
     return 1
 
 if __name__ == '__main__':
   sys.exit(main())