Add Flash binary path option to bisect script.

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 11 matching lines @@
 # 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'
+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 shlex
 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, base_url, platform, good_revision, bad_revision,
-               is_official, is_aura):
+               is_official, is_aura, flash_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.flash_path = flash_path
 
     # The name of the ZIP file in a revision directory on the server.
     self.archive_name = None
 
     # Set some internal members:
     #   _listing_platform_dir = Directory that holds revisions. Ends with a '/'.
     #   _archive_extract_dir = Uncompressed directory in the archive_name file.
     #   _binary_name = The name of the executable to run.
     if self.platform in ('linux', 'linux64', 'linux-arm'):
       self._binary_name = 'chrome'
@@ skipping 194 matching lines @@
           # 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.IsASANBuild(str(build_number))):
             final_list.append(str(build_number))
       except urllib.HTTPError, e:
         pass
     return final_list
 
-def UnzipFilenameToDir(filename, dir):
-  """Unzip |filename| to directory |dir|."""
+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)
   # Make base.
-  if not os.path.isdir(dir):
-    os.mkdir(dir)
-  os.chdir(dir)
+  if not os.path.isdir(directory):
+    os.mkdir(directory)
+  os.chdir(directory)
   # Extract files.
   for info in zf.infolist():
     name = info.filename
     if name.endswith('/'):  # dir
       if not os.path.isdir(name):
         os.makedirs(name)
     else:  # file
-      dir = os.path.dirname(name)
-      if not os.path.isdir(dir):
-        os.makedirs(dir)
+      directory = os.path.dirname(name)
+      if not os.path.isdir(directory):
+        os.makedirs(directory)
       out = open(name, 'wb')
       out.write(zf.read(name))
       out.close()
     # Set permissions. Permission info in external_attr is shifted 16 bits.
     os.chmod(name, info.external_attr >> 16L)
   os.chdir(cwd)
 
 
 def FetchRevision(context, rev, filename, quit_event=None, progress_event=None):
   """Downloads and unzips revision |rev|.
@@ skipping 36 matching lines @@
 
   # Create a temp directory and unzip the revision into it.
   cwd = os.getcwd()
   tempdir = tempfile.mkdtemp(prefix='bisect_tmp')
   UnzipFilenameToDir(zipfile, tempdir)
   os.chdir(tempdir)
 
   # Run the build as many times as specified.
   testargs = ['--user-data-dir=%s' % profile] + args
   # The sandbox must be run as root on Official Chrome, so bypass it.
-  if context.is_official and context.platform.startswith('linux'):
+  if ((context.is_official or context.flash_path) and
+      context.platform.startswith('linux')):
     testargs.append('--no-sandbox')
+  if context.flash_path:
+    testargs.append('--ppapi-flash-path=%s' % context.flash_path)
+    # We have to pass a large enough Flash version, which currently needs not
+    # be correct. Instead of requiring the user of the script to figure out and
+    # pass the correct version we just spoof it.
+    testargs.append('--ppapi-flash-version=99.9.999.999')
 
   runcommand = []
   for token in shlex.split(command):
     if token == "%a":
       runcommand.extend(testargs)
     else:
       runcommand.append( \
           token.replace('%p', context.GetLaunchPath()) \
                .replace('%s', ' '.join(testargs)))
 
@@ skipping 67 matching lines @@
 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,
+           flash_path=None,
            evaluate=AskIsGoodBuild):
   """Given known good and known bad revisions, run a binary search on all
   archived revisions to determine the last known good revision.
 
   @param platform Which build to download/run ('mac', 'win', 'linux64', etc.).
   @param official_builds Specify build type (Chromium or Official build).
   @param good_rev Number/tag of the known good revision.
   @param bad_rev Number/tag of the known bad revision.
   @param num_runs Number of times to run each build for asking good/bad.
   @param try_args A tuple of arguments to pass to the test application.
@@ skipping 13 matching lines @@
       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(base_url, platform, good_rev, bad_rev,
-                        official_builds, is_aura)
+                        official_builds, is_aura, flash_path)
   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()
 
@@ skipping 48 matching lines @@
     stderr = None
     try:
       (status, stdout, stderr) = RunRevision(context,
                                              rev,
                                              fetch.zipfile,
                                              profile,
                                              num_runs,
                                              command,
                                              try_args)
     except Exception, e:
-      print >>sys.stderr, e
+      print >> sys.stderr, e
 
     # Call the evaluate function to see if the current revision is good or bad.
     # On that basis, kill one of the background downloads and complete the
     # other, as described in the comments above.
     try:
       answer = evaluate(rev, official_builds, status, stdout, stderr)
       if answer == 'g' and good_rev < bad_rev or \
           answer == 'b' and bad_rev < good_rev:
         fetch.Stop()
         minrev = pivot
@@ skipping 146 matching lines @@
                     help = 'The buildbot archive to bisect [%s].' %
                            '|'.join(choices))
   parser.add_option('-o', action="store_true", dest='official_builds',
                     help = 'Bisect across official ' +
                     'Chrome builds (internal only) instead of ' +
                     'Chromium archives.')
   parser.add_option('-b', '--bad', type = 'str',
                     help = 'A bad revision to start bisection. ' +
                     'May be earlier or later than the good revision. ' +
                     'Default is HEAD.')
+  parser.add_option('-f', '--flash_path', type = 'str',
+                    help = 'Absolute path to a recent Adobe Pepper Flash ' +
+                    'binary to be used in this bisection (e.g. ' +
+                    'on Windows C:\...\pepflashplayer.dll and on Linux ' +
+                    '/opt/google/chrome/PepperFlash/libpepflashplayer.so).')
   parser.add_option('-g', '--good', type = 'str',
                     help = 'A good revision to start bisection. ' +
                     'May be earlier or later than the bad revision. ' +
                     'Default is 0.')
   parser.add_option('-p', '--profile', '--user-data-dir', type = 'str',
                     help = 'Profile to use; this will not reset every run. ' +
                     'Defaults to a clean profile.', default = 'profile')
   parser.add_option('-t', '--times', type = 'int',
                     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');
+                    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(base_url, opts.archive, 0, 0,
-                        opts.official_builds, opts.aura)
+                        opts.official_builds, opts.aura, None)
   # 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.flash_path:
+    flash_path = opts.flash_path
+    msg = 'Could not find Flash binary at %s' % flash_path
+    assert os.path.exists(flash_path), msg
+
   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(
       base_url, opts.archive, opts.official_builds, opts.aura, good_rev,
-      bad_rev, opts.times, opts.command, args, opts.profile)
+      bad_rev, opts.times, opts.command, args, opts.profile, opts.flash_path)
 
   # Get corresponding blink revisions.
   try:
     min_blink_rev = GetBlinkRevisionForChromiumRevision(context,
                                                         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
@@ skipping 21 matching lines @@
              "you might also want to do a Blink bisect.")
 
     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())