bisect-builds.py: Cleanup the code related to bisecting official aura builds.

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,
@@ skipping 75 matching lines @@
 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, base_url, platform, good_revision, bad_revision,
-               is_official, is_aura, is_asan, use_local_repo, flash_path = None,
+               is_official, is_asan, use_local_repo, flash_path = None,
                pdf_path = None):
     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
     self.is_asan = is_asan
     self.build_type = 'release'
     self.flash_path = flash_path
     # Dictionary which stores svn revision number as key and it's
     # corresponding git hash as value. This data is populated in
     # _FetchAndParse and used later in GetDownloadURL while downloading
     # the build.
     self.githash_svn_dict = {}
     self.pdf_path = pdf_path
 
@@ skipping 28 matching lines @@
         self.archive_name = 'chrome-precise32bit.zip'
         self._archive_extract_dir = 'chrome-precise32bit'
       elif self.platform == 'linux64':
         self._listing_platform_dir = 'precise64bit/'
         self.archive_name = 'chrome-precise64bit.zip'
         self._archive_extract_dir = 'chrome-precise64bit'
       elif self.platform == 'mac':
         self._listing_platform_dir = 'mac/'
         self._binary_name = 'Google Chrome.app/Contents/MacOS/Google Chrome'
       elif self.platform == 'win':
-        if self.is_aura:
-          self._listing_platform_dir = 'win-aura/'
-        else:
-          self._listing_platform_dir = 'win/'
+        self._listing_platform_dir = 'win/'
     else:
       if self.platform in ('linux', 'linux64', 'linux-arm'):
         self.archive_name = 'chrome-linux.zip'
         self._archive_extract_dir = 'chrome-linux'
         if self.platform == 'linux':
           self._listing_platform_dir = 'Linux/'
         elif self.platform == 'linux64':
           self._listing_platform_dir = 'Linux_x64/'
         elif self.platform == 'linux-arm':
           self._listing_platform_dir = 'Linux_ARM_Cross-Compile/'
@@ skipping 54 matching lines @@
 
   def GetLaunchPath(self, revision):
     """Returns a relative path (presumably from the archive extraction location)
     that is used to run the executable."""
     if self.is_asan:
       extract_dir = '%s-%d' % (self.GetASANBaseName(), revision)
     else:
       extract_dir = self._archive_extract_dir
     return os.path.join(extract_dir, self._binary_name)
 
-  @staticmethod
-  def IsAuraBuild(build):
-    """Checks whether the given build is an Aura build."""
-    return build.split('.')[3] == '1'
-
-  @staticmethod
-  def IsOfficialASANBuild(build):
-    """Checks whether the given build is an ASAN build."""
-    return build.split('.')[3] == '2'
-
   def ParseDirectoryIndex(self):
     """Parses the Google Storage directory listing into a list of revision
     numbers."""
 
     def _FetchAndParse(url):
       """Fetches a URL and returns a 2-Tuple of ([revisions], next-marker). If
       next-marker is not None, then the listing is a partial listing and another
       fetch should be performed with next-marker being the marker= GET
       parameter."""
       handle = urllib.urlopen(url)
@@ skipping 168 matching lines @@
     for build_number in sorted(parsed_build_numbers):
       path = (OFFICIAL_BASE_URL + '/' + str(build_number) + '/' +
               self._listing_platform_dir + self.archive_name)
       i = i + 1
       try:
         connection = urllib.urlopen(path)
         connection.close()
         if build_number > maxrev:
           break
         if build_number >= minrev:
-          # If we are bisecting Aura, we want to include only builds which
-          # ends with ".1".
-          if self.is_aura:
-            if self.IsAuraBuild(str(build_number)):
-              final_list.append(str(build_number))
-          # If we are bisecting only official builds (without --aura),
-          # we can not include builds which ends with '.1' or '.2' since
-          # they have different folder hierarchy inside.
-          elif (not self.IsAuraBuild(str(build_number)) and
-                not self.IsOfficialASANBuild(str(build_number))):
-            final_list.append(str(build_number))
+          final_list.append(str(build_number))
       except urllib.HTTPError:
         pass
     return final_list
 
 def UnzipFilenameToDir(filename, directory):
   """Unzip |filename| to |directory|."""
   cwd = os.getcwd()
   if not os.path.isabs(filename):
     filename = os.path.join(cwd, filename)
   zf = zipfile.ZipFile(filename)
@@ skipping 533 matching lines @@
                          'respectively. Use %s to specify all extra arguments '
                          'as one string. Defaults to "%p %a". Note that any '
                          'extra paths specified should be absolute.')
   parser.add_option('-l', '--blink',
                     action='store_true',
                     help='Use Blink bisect instead of Chromium. ')
   parser.add_option('', '--not-interactive',
                     action='store_true',
                     default=False,
                     help='Use command exit code to tell good/bad revision.')
-  parser.add_option('--aura',
-                    dest='aura',
-                    action='store_true',
-                    default=False,
-                    help='Allow the script to bisect aura builds')
   parser.add_option('--asan',
                     dest='asan',
                     action='store_true',
                     default=False,
                     help='Allow the script to bisect ASAN builds')
   parser.add_option('--use-local-repo',
                     dest='use_local_repo',
                     action='store_true',
                     default=False,
                     help='Allow the script to convert git SHA1 to SVN '
                          'revision using "git svn find-rev <SHA1>" '
                          'command from a Chromium checkout.')
 
   (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.asan:
     supported_platforms = ['linux', 'mac', 'win']
     if opts.archive not in supported_platforms:
       print 'Error: ASAN bisecting only supported on these platforms: [%s].' % (
             '|'.join(supported_platforms))
       return 1
     if opts.official_builds:
       print 'Error: Do not yet support bisecting official ASAN builds.'
       return 1
 
   if opts.asan:
     base_url = ASAN_BASE_URL
   elif 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(base_url, opts.archive, opts.good, opts.bad,
-                        opts.official_builds, opts.aura, opts.asan,
-                        opts.use_local_repo, opts.flash_path, opts.pdf_path)
+                        opts.official_builds, opts.asan, opts.use_local_repo,
+                        opts.flash_path, opts.pdf_path)
   # Pick a starting point, try to get HEAD for this.
   if not opts.bad:
     context.bad_revision = '999.0.0.0'
     context.bad_revision = GetChromiumRevision(
         context, context.GetLastChangeURL())
 
   # Find out when we were good.
   if not opts.good:
     context.good_revision = '0.0.0.0' if opts.official_builds else 0
 
@@ skipping 66 matching lines @@
 
     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())