add the option to bisect blink builds as well and have blink revisions look in the REVISIONS file a…

tools/bisect-builds.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Snapshot Build Bisect Tool
 
 This script bisects a snapshot archive using binary search. It starts at
 a bad revision (it will try to guess HEAD) and asks for a last known-good
 revision. It will then binary search across this revision range by downloading,
 unzipping, and opening Chromium for you. After testing the specific revision,
 it will ask you whether it is good or bad before continuing the search.
 """
 
 # The root URL for storage.
-BASE_URL = 'http://commondatastorage.googleapis.com/chromium-browser-snapshots'
+CHROMIUM_BASE_URL = 'http://commondatastorage.googleapis.com/chromium-browser-snapshots'
+WEBKIT_BASE_URL = 'http://commondatastorage.googleapis.com/chromium-webkit-snapshots'
 
 # The root URL for official builds.
 OFFICIAL_BASE_URL = 'http://master.chrome.corp.google.com/official_builds'
 
 # Changelogs URL.
 CHANGELOG_URL = 'http://build.chromium.org/f/chromium/' \
                 'perf/dashboard/ui/changelog.html?' \
                 'url=/trunk/src&range=%d%%3A%d'
 
 # Official Changelogs URL.
 OFFICIAL_CHANGELOG_URL = 'http://omahaproxy.appspot.com/'\
                          'changelog?old_version=%s&new_version=%s'
 
 # DEPS file URL.
 DEPS_FILE= 'http://src.chromium.org/viewvc/chrome/trunk/src/DEPS?revision=%d'
 # Blink Changelogs URL.
 BLINK_CHANGELOG_URL = 'http://build.chromium.org/f/chromium/' \
                       'perf/dashboard/ui/changelog_blink.html?' \
                       'url=/trunk&range=%d%%3A%d'
 
 DONE_MESSAGE_GOOD_MIN = 'You are probably looking for a change made after %s ' \
                         '(known good), but no later than %s (first known bad).'
 DONE_MESSAGE_GOOD_MAX = 'You are probably looking for a change made after %s ' \
                         '(known bad), but no later than %s (first known good).'
 
 ###############################################################################
 
+import json
 import math
 import optparse
 import os
 import pipes
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 import threading
 import urllib
 from distutils.version import LooseVersion
 from xml.etree import ElementTree
 import zipfile
 
 
 class PathContext(object):
   """A PathContext is used to carry the information used to construct URLs and
   paths when dealing with the storage server and archives."""
-  def __init__(self, platform, good_revision, bad_revision, is_official,
-               is_aura):
+  def __init__(self, base_url, platform, good_revision, bad_revision,
+               is_official, is_aura):
     super(PathContext, self).__init__()
     # Store off the input parameters.
+    self.base_url = base_url
     self.platform = platform  # What's passed in to the '-a/--archive' option.
     self.good_revision = good_revision
     self.bad_revision = bad_revision
     self.is_official = is_official
     self.is_aura = is_aura
 
     # The name of the ZIP file in a revision directory on the server.
     self.archive_name = None
 
     # Set some internal members:
@@ skipping 43 matching lines @@
         self._listing_platform_dir = 'Mac/'
         self._binary_name = 'Chromium.app/Contents/MacOS/Chromium'
       elif self.platform == 'win':
         self._listing_platform_dir = 'Win/'
 
   def GetListingURL(self, marker=None):
     """Returns the URL for a directory listing, with an optional marker."""
     marker_param = ''
     if marker:
       marker_param = '&marker=' + str(marker)
-    return BASE_URL + '/?delimiter=/&prefix=' + self._listing_platform_dir + \
-        marker_param
+    return self.base_url + '/?delimiter=/&prefix=' + \
+        self._listing_platform_dir + marker_param
 
   def GetDownloadURL(self, revision):
     """Gets the download URL for a build archive of a specific revision."""
     if self.is_official:
       return "%s/%s/%s%s" % (
           OFFICIAL_BASE_URL, revision, self._listing_platform_dir,
           self.archive_name)
     else:
-      return "%s/%s%s/%s" % (
-          BASE_URL, self._listing_platform_dir, revision, self.archive_name)
+      return "%s/%s%s/%s" % (self.base_url, self._listing_platform_dir,
+                             revision, self.archive_name)
 
   def GetLastChangeURL(self):
     """Returns a URL to the LAST_CHANGE file."""
-    return BASE_URL + '/' + self._listing_platform_dir + 'LAST_CHANGE'
+    return self.base_url + '/' + self._listing_platform_dir + 'LAST_CHANGE'
 
   def GetLaunchPath(self):
     """Returns a relative path (presumably from the archive extraction location)
     that is used to run the executable."""
     return os.path.join(self._archive_extract_dir, self._binary_name)
 
   def IsAuraBuild(self, build):
     """Check the given build is Aura."""
     return build.split('.')[3] == '1'
 
@@ skipping 253 matching lines @@
     os.unlink(self.zipfile)
 
   def WaitFor(self):
     """Prints a message and waits for the download to complete. The download
     must have been started previously."""
     print "Downloading revision %s..." % str(self.rev)
     self.progress_event.set()  # Display progress of download.
     self.thread.join()
 
 
-def Bisect(platform,
+def Bisect(base_url,
+           platform,
            official_builds,
            is_aura,
            good_rev=0,
            bad_rev=0,
            num_runs=1,
            command="%p %a",
            try_args=(),
            profile=None,
            evaluate=AskIsGoodBuild):
   """Given known good and known bad revisions, run a binary search on all
@@ skipping 20 matching lines @@
     - If rev 50 is good, the download of rev 25 is cancelled, and the next test
       is run on rev 75.
 
     - If rev 50 is bad, the download of rev 75 is cancelled, and the next test
       is run on rev 25.
   """
 
   if not profile:
     profile = 'profile'
 
-  context = PathContext(platform, good_rev, bad_rev, official_builds, is_aura)
+  context = PathContext(base_url, platform, good_rev, bad_rev,
+                        official_builds, is_aura)
   cwd = os.getcwd()
 
-
-
   print "Downloading list of known revisions..."
   _GetDownloadPath = lambda rev: os.path.join(cwd,
       '%s-%s' % (str(rev), context.archive_name))
   if official_builds:
     revlist = context.GetOfficialBuildsList()
   else:
     revlist = context.GetRevList()
 
   # Get a list of revisions to bisect across.
   if len(revlist) < 2:  # Don't have enough builds to bisect.
@@ skipping 124 matching lines @@
         except OSError:
           pass
       sys.exit(0)
 
     rev = revlist[pivot]
 
   return (revlist[minrev], revlist[maxrev])
 
 
 def GetBlinkRevisionForChromiumRevision(rev):
-  """Returns the blink revision that was in chromium's DEPS file at
+  """Returns the blink revision that was in REVISIONS file at
   chromium revision |rev|."""
   # . doesn't match newlines without re.DOTALL, so this is safe.
-  blink_re = re.compile(r'webkit_revision.:\D*(\d+)')
-  url = urllib.urlopen(DEPS_FILE % rev)
-  m = blink_re.search(url.read())
+  file_url = "%s/%s%d/REVISIONS" % (self.base_url,
+                                    self._listing_platform_dir, rev)
+  url = urllib.urlopen(file_url)
+  data = json.loads(url.read())
   url.close()
-  if m:
-    return int(m.group(1))
+  if data['webkit_revision']:
+    return data['webkit_revision']
   else:
-    raise Exception('Could not get blink revision for cr rev %d' % rev)
+    raise Exception('Could not get webkit revision for cr rev %d' % rev)
 
 
 def GetChromiumRevision(url):
   """Returns the chromium revision read from given URL."""
   try:
     # Location of the latest build revision number
     return int(urllib.urlopen(url).read())
   except Exception, e:
     print('Could not determine latest revision. This could be bad...')
     return 999999999
@@ skipping 43 matching lines @@
                     help = 'Number of times to run each build before asking ' +
                     'if it\'s good or bad. Temporary profiles are reused.',
                     default = 1)
   parser.add_option('-c', '--command', type = 'str',
                     help = 'Command to execute. %p and %a refer to Chrome ' +
                     'executable and specified extra arguments respectively. ' +
                     'Use %s to specify all extra arguments as one string. ' +
                     'Defaults to "%p %a". Note that any extra paths ' +
                     'specified should be absolute.',
                     default = '%p %a');
+  parser.add_option('-l', '--blink', action='store_true',
+                    help = 'Use Blink bisect instead of Chromium. ')
   parser.add_option('--aura',
                     dest='aura',
                     action='store_true',
                     default=False,
                     help='Allow the script to bisect aura builds')
 
   (opts, args) = parser.parse_args()
 
   if opts.archive is None:
     print 'Error: missing required parameter: --archive'
     print
     parser.print_help()
     return 1
 
   if opts.aura:
     if opts.archive != 'win' or not opts.official_builds:
       print 'Error: Aura is supported only on Windows platform '\
             'and official builds.'
       return 1
 
+  if opts.blink:
+    base_url = WEBKIT_BASE_URL
+  else:
+    base_url = CHROMIUM_BASE_URL
+
+
   # Create the context. Initialize 0 for the revisions as they are set below.
-  context = PathContext(opts.archive, 0, 0, opts.official_builds, opts.aura)
+  context = PathContext(base_url, opts.archive, 0, 0,
+                        opts.official_builds, opts.aura)
   # Pick a starting point, try to get HEAD for this.
   if opts.bad:
     bad_rev = opts.bad
   else:
     bad_rev = '999.0.0.0'
     if not opts.official_builds:
       bad_rev = GetChromiumRevision(context.GetLastChangeURL())
 
   # Find out when we were good.
   if opts.good:
     good_rev = opts.good
   else:
     good_rev = '0.0.0.0' if opts.official_builds else 0
 
   if opts.official_builds:
     good_rev = LooseVersion(good_rev)
     bad_rev = LooseVersion(bad_rev)
   else:
     good_rev = int(good_rev)
     bad_rev = int(bad_rev)
 
   if opts.times < 1:
     print('Number of times to run (%d) must be greater than or equal to 1.' %
           opts.times)
     parser.print_help()
     return 1
 
   (min_chromium_rev, max_chromium_rev) = Bisect(
-      opts.archive, opts.official_builds, opts.aura, good_rev, bad_rev,
-      opts.times, opts.command, args, opts.profile)
+      base_url, opts.archive, opts.official_builds, opts.aura, good_rev,
+      bad_rev, opts.times, opts.command, args, opts.profile)
 
   # Get corresponding blink revisions.
   try:
-    min_blink_rev = GetBlinkRevisionForChromiumRevision(min_chromium_rev)
-    max_blink_rev = GetBlinkRevisionForChromiumRevision(max_chromium_rev)
+    min_blink_rev = GetBlinkRevisionForChromiumRevision(context,

[Dirk Pranke, 2013/09/17 00:42:18]

I don't think you need (or want) the 'context' parameter on these two calls.

You probably also shouldn't be silently ignoring the failures, since they
shouldn't happen if I am understanding things correctly.

+                                                        min_chromium_rev)
+    max_blink_rev = GetBlinkRevisionForChromiumRevision(context,
+                                                        max_chromium_rev)
   except Exception, e:
     # Silently ignore the failure.
     min_blink_rev, max_blink_rev = 0, 0
 
   # We're done. Let the user know the results in an official manner.
   if good_rev > bad_rev:
     print DONE_MESSAGE_GOOD_MAX % (str(min_chromium_rev), str(max_chromium_rev))
   else:
     print DONE_MESSAGE_GOOD_MIN % (str(min_chromium_rev), str(max_chromium_rev))
 
   if min_blink_rev != max_blink_rev:
     print 'BLINK CHANGELOG URL:'
     print '  ' + BLINK_CHANGELOG_URL % (max_blink_rev, min_blink_rev)
   print 'CHANGELOG URL:'
   if opts.official_builds:
     print OFFICIAL_CHANGELOG_URL % (min_chromium_rev, max_chromium_rev)
   else:
     print '  ' + CHANGELOG_URL % (min_chromium_rev, max_chromium_rev)
 
 if __name__ == '__main__':
   sys.exit(main())