First pass android support in bisect script.

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 344 matching lines @@
           opts.output_buildbot_annotations)
     elif opts.build_preference == 'msvs':
       assert IsWindows(), 'msvs is only supported on Windows.'
       build_success = BuildWithVisualStudio(targets,
           opts.output_buildbot_annotations)
     else:
       assert False, 'No build system defined.'
     return build_success
 
 
+class AndroidBuilder(Builder):
+  """AndroidBuilder is used to build on android."""
+  def InstallAPK(self, opts):
+    """Installs apk to device.
+
+    Args:
+        opts: The options parsed from the command line.
+
+    Returns:
+        True if successful.
+    """
+    path_to_tool = os.path.join('build', 'android', 'adb_install_apk.py')
+    cmd = [path_to_tool, '--apk', 'ContentShell.apk', '--apk_package',
+        'org.chromium.content_shell_apk', '--release']
+    (_, return_code) = RunProcess(cmd, opts.output_buildbot_annotations)
+    return not return_code
+
+  def Build(self, depot, opts):
+    """Builds the android content shell and other necessary tools using options
+    passed into the script.
+
+    Args:
+        depot: Current depot being bisected.
+        opts: The options parsed from the command line.
+
+    Returns:
+        True if build was successful.
+    """
+    targets = ['content_shell_apk', 'forwarder2', 'md5sum']
+    threads = 16
+    if opts.use_goma:
+      threads = 64
+
+    build_success = False
+    if opts.build_preference == 'ninja':
+      build_success = BuildWithNinja(threads, targets,
+          opts.output_buildbot_annotations)
+    else:
+      assert False, 'No build system defined.'
+
+    if build_success:
+      build_success = self.InstallAPK(opts)
+
+    return build_success
+
+
 class CrosBuilder(Builder):
   """CrosBuilder is used to build and image ChromeOS/Chromium when cros is the
   target platform."""
   def ImageToTarget(self, opts):
     """Installs latest image to target specified by opts.cros_remote_ip.
 
     Args:
         opts: Program options containing cros_board and cros_remote_ip.
 
     Returns:
@@ skipping 346 matching lines @@
     self.source_control = source_control
     self.src_cwd = os.getcwd()
     self.cros_cwd = os.path.join(os.getcwd(), '..', 'cros')
     self.depot_cwd = {}
     self.cleanup_commands = []
     self.warnings = []
     self.builder = None
 
     if opts.target_platform == 'cros':
       self.builder = CrosBuilder()
+    elif opts.target_platform == 'android':
+      self.builder = AndroidBuilder()
     else:
       self.builder = DesktopBuilder()
 
     # This always starts true since the script grabs latest first.
     self.was_blink = True
 
     for d in DEPOT_NAMES:
       # The working directory of each depot is just the path to the depot, but
       # since we're already in 'src', we can skip that part.
 
@@ skipping 549 matching lines @@
       os.chdir(self.depot_cwd[current_depot])
 
     depot_revision_list = self.GetRevisionList(current_depot,
                                                end_revision,
                                                start_revision)
 
     os.chdir(old_cwd)
 
     return depot_revision_list
 
-  def GatherReferenceValues(self, good_rev, bad_rev, cmd, metric):
+  def GatherReferenceValues(self, good_rev, bad_rev, cmd, metric, target_depot):
     """Gathers reference values by running the performance tests on the
     known good and bad revisions.
 
     Args:
       good_rev: The last known good revision where the performance regression
         has not occurred yet.
       bad_rev: A revision where the performance regression has already occurred.
       cmd: The command to execute the performance test.
       metric: The metric being tested for regression.
 
     Returns:
       A tuple with the results of building and running each revision.
     """
     bad_run_results = self.SyncBuildAndRunRevision(bad_rev,
-                                                   self.opts.target_platform,
+                                                   target_depot,
                                                    cmd,
                                                    metric)
 
     good_run_results = None
 
     if not bad_run_results[1]:
       good_run_results = self.SyncBuildAndRunRevision(good_rev,
-                                                      self.opts.target_platform,
+                                                      target_depot,
                                                       cmd,
                                                       metric)
 
     return (bad_run_results, good_run_results)
 
   def AddRevisionsIntoRevisionData(self, revisions, depot, sort, revision_data):
     """Adds new revisions to the revision_data dict and initializes them.
 
     Args:
       revisions: List of revisions to add.
@@ skipping 195 matching lines @@
       if self.opts.output_buildbot_annotations:
         bisect_utils.OutputAnnotationStepStart('Gathering Reference Values')
 
       print 'Gathering reference values for bisection.'
 
       # Perform the performance tests on the good and bad revisions, to get
       # reference values.
       (bad_results, good_results) = self.GatherReferenceValues(good_revision,
                                                                bad_revision,
                                                                command_to_run,
-                                                               metric)
+                                                               metric,
+                                                               target_depot)
 
       if self.opts.output_buildbot_annotations:
         bisect_utils.OutputAnnotationStepClosed()
 
       if bad_results[1]:
         results['error'] = bad_results[0]
         return results
 
       if good_results[1]:
         results['error'] = good_results[0]
@@ skipping 519 matching lines @@
                     'Default value is 25 (highest/lowest 25% will be '
                     'discarded).')
   parser.add_option('--build_preference',
                     type='choice',
                     choices=['msvs', 'ninja', 'make'],
                     help='The preferred build system to use. On linux/mac '
                     'the options are make/ninja. On Windows, the options '
                     'are msvs/ninja.')
   parser.add_option('--target_platform',
                     type='choice',
-                    choices=['chromium', 'cros'],
+                    choices=['chromium', 'cros', 'android'],
                     default='chromium',
-                    help='The target platform. Choices are "default" (current '
-                    'platform, or "cros". If choosing "cros", you '
-                    'must be properly set up to build.')
+                    help='The target platform. Choices are "chromium" (current '
+                    'platform), "cros", or "android". If you specify something '
+                    'other than "chromium", you must be properly set up to '
+                    'build that platform.')
   parser.add_option('--cros_board',
                     type='str',
                     help='The cros board type to build.')
   parser.add_option('--cros_remote_ip',
                     type='str',
                     help='The remote machine to image to.')
   parser.add_option('--use_goma',
                     action="store_true",
                     help='Add a bunch of extra threads for goma.')
   parser.add_option('--output_buildbot_annotations',
@@ skipping 66 matching lines @@
   metric_values = opts.metric.split('/')
   if len(metric_values) != 2:
     print "Invalid metric specified: [%s]" % (opts.metric,)
     print
     return 1
 
   if opts.working_directory:
     if bisect_utils.CreateBisectDirectoryAndSetupDepot(opts):
       return 1
 
-    if opts.target_platform == 'cros':
-      if not bisect_utils.SetupCrosRepo():
-        print 'Error: Failed to grab cros source.'
-        print
-        return 1
+    if not bisect_utils.SetupPlatformBuildEnvironment(opts):
+      print 'Error: Failed to set platform environment.'
+      print
+      return 1
 
     os.chdir(os.path.join(os.getcwd(), 'src'))
 
     if not RemoveBuildFiles():
       print "Something went wrong removing the build files."
       print
       return 1
 
   if not CheckPlatformSupported(opts):
     return 1
@@ skipping 26 matching lines @@
 
   if not(bisect_results['error']):
     return 0
   else:
     print 'Error: ' + bisect_results['error']
     print
     return 1
 
 if __name__ == '__main__':
   sys.exit(main())