tools/auto_bisect/builder.py

   1 # Copyright 2014 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 """Classes and functions for building Chrome.
   6
   7 This includes functions for running commands to build, as well as
   8 specific rules about which targets to build.
   9 """
  10
  11 import os
  12 import subprocess
  13 import sys
  14
  15 import bisect_utils
  16
  17 ORIGINAL_ENV = {}
  18
  19
  20 class Builder(object):
  21   """Subclasses of the Builder class are used by the bisect script to build
  22   relevant targets.
  23   """
  24   def __init__(self, opts):
  25     """Performs setup for building with target build system.
  26
  27     Args:
  28       opts: Options parsed from command line.
  29
  30     Raises:
  31       RuntimeError: Some condition necessary for building was not met.
  32     """
  33     if bisect_utils.IsWindowsHost():
  34       if not opts.build_preference:
  35         opts.build_preference = 'msvs'
  36
  37       if opts.build_preference == 'msvs':
  38         if not os.getenv('VS100COMNTOOLS'):
  39           raise RuntimeError(
  40               'Path to visual studio could not be determined.')
  41       else:
  42         # Need to re-escape goma dir, see crbug.com/394990.
  43         if opts.goma_dir:
  44           opts.goma_dir = opts.goma_dir.encode('string_escape')
  45         SetBuildSystemDefault(opts.build_preference, opts.use_goma,
  46                               opts.goma_dir, opts.target_arch)
  47     else:
  48       if not opts.build_preference:
  49         if 'ninja' in os.getenv('GYP_GENERATORS', default=''):
  50           opts.build_preference = 'ninja'
  51         else:
  52           opts.build_preference = 'make'
  53
  54       SetBuildSystemDefault(opts.build_preference, opts.use_goma, opts.goma_dir)
  55
  56     if not SetupPlatformBuildEnvironment(opts):
  57       raise RuntimeError('Failed to set platform environment.')
  58
  59   @staticmethod
  60   def FromOpts(opts):
  61     """Constructs and returns a Builder object.
  62
  63     Args:
  64       opts: Options parsed from the command-line.
  65     """
  66     builder = None
  67     if opts.target_platform == 'android':
  68       builder = AndroidBuilder(opts)
  69     elif opts.target_platform == 'android-chrome':
  70       builder = AndroidChromeBuilder(opts)
  71     else:
  72       builder = DesktopBuilder(opts)
  73     return builder
  74
  75   def Build(self, depot, opts):
  76     """Runs a command to build Chrome."""
  77     raise NotImplementedError()
  78
  79
  80 def GetBuildOutputDirectory(opts, src_dir=None):
  81   """Returns the path to the build directory, relative to the checkout root.
  82
  83   Assumes that the current working directory is the checkout root.
  84
  85   Args:
  86     opts: Command-line options.
  87     src_dir: Path to chromium/src directory.
  88
  89   Returns:
  90     A path to the directory to use as build output directory.
  91
  92   Raises:
  93     NotImplementedError: The platform according to sys.platform is unexpected.
  94   """
  95   src_dir = src_dir or 'src'
  96   if opts.build_preference == 'ninja' or bisect_utils.IsLinuxHost():
  97     return os.path.join(src_dir, 'out')
  98   if bisect_utils.IsMacHost():
  99     return os.path.join(src_dir, 'xcodebuild')
 100   if bisect_utils.IsWindowsHost():
 101     return os.path.join(src_dir, 'build')
 102   raise NotImplementedError('Unexpected platform %s' % sys.platform)
 103
 104
 105 class DesktopBuilder(Builder):
 106   """DesktopBuilder is used to build Chromium on Linux, Mac, or Windows."""
 107
 108   def __init__(self, opts):
 109     super(DesktopBuilder, self).__init__(opts)
 110
 111   def Build(self, depot, opts):
 112     """Builds chromium_builder_perf target using options passed into the script.
 113
 114     Args:
 115       depot: Name of current depot being bisected.
 116       opts: The options parsed from the command line.
 117
 118     Returns:
 119       True if build was successful.
 120     """
 121     targets = ['chromium_builder_perf']
 122
 123     threads = None
 124     if opts.use_goma:
 125       threads = opts.goma_threads
 126
 127     build_success = False
 128     if opts.build_preference == 'make':
 129       build_success = BuildWithMake(threads, targets, opts.target_build_type)
 130     elif opts.build_preference == 'ninja':
 131       build_success = BuildWithNinja(threads, targets, opts.target_build_type)
 132     elif opts.build_preference == 'msvs':
 133       assert bisect_utils.IsWindowsHost(), 'msvs is only supported on Windows.'
 134       build_success = BuildWithVisualStudio(targets, opts.target_build_type)
 135     else:
 136       assert False, 'No build system defined.'
 137     return build_success
 138
 139
 140 class AndroidBuilder(Builder):
 141   """AndroidBuilder is used to build on android."""
 142
 143   def __init__(self, opts):
 144     super(AndroidBuilder, self).__init__(opts)
 145
 146   # TODO(qyearsley): Make this a class method and verify that it works with
 147   # a unit test.
 148   # TODO (prasadv): Remove android-chrome-shell target once we confirm there are
 149   # no pending bisect jobs with this in command.
 150   # pylint: disable=R0201
 151   def _GetTargets(self):
 152     """Returns a list of build targets."""
 153     return [
 154         'chrome_public_apk',
 155         'chrome_shell_apk',
 156         'cc_perftests_apk',
 157         'android_tools'
 158     ]
 159
 160   def Build(self, depot, opts):
 161     """Builds the android content shell and other necessary tools.
 162
 163     Args:
 164         depot: Current depot being bisected.
 165         opts: The options parsed from the command line.
 166
 167     Returns:
 168         True if build was successful.
 169     """
 170     threads = None
 171     if opts.use_goma:
 172       threads = opts.goma_threads
 173
 174     build_success = False
 175     if opts.build_preference == 'ninja':
 176       build_success = BuildWithNinja(
 177           threads, self._GetTargets(), opts.target_build_type)
 178     else:
 179       assert False, 'No build system defined.'
 180
 181     return build_success
 182
 183
 184 class AndroidChromeBuilder(AndroidBuilder):
 185   """AndroidChromeBuilder is used to build "android-chrome".
 186
 187   This is slightly different from AndroidBuilder.
 188   """
 189
 190   def __init__(self, opts):
 191     super(AndroidChromeBuilder, self).__init__(opts)
 192
 193   # TODO(qyearsley): Make this a class method and verify that it works with
 194   # a unit test.
 195   # pylint: disable=R0201
 196   def _GetTargets(self):
 197     """Returns a list of build targets."""
 198     return AndroidBuilder._GetTargets(self) + ['chrome_apk']
 199
 200
 201 def SetBuildSystemDefault(build_system, use_goma, goma_dir, target_arch='ia32'):
 202   """Sets up any environment variables needed to build with the specified build
 203   system.
 204
 205   Args:
 206     build_system: A string specifying build system. Currently only 'ninja' or
 207         'make' are supported.
 208     use_goma: Determines whether to GOMA for compile.
 209     goma_dir: GOMA directory path.
 210     target_arch: The target build architecture, ia32 or x64. Default is ia32.
 211   """
 212   if build_system == 'ninja':
 213     gyp_var = os.getenv('GYP_GENERATORS', default='')
 214
 215     if not gyp_var or not 'ninja' in gyp_var:
 216       if gyp_var:
 217         os.environ['GYP_GENERATORS'] = gyp_var + ',ninja'
 218       else:
 219         os.environ['GYP_GENERATORS'] = 'ninja'
 220
 221       if bisect_utils.IsWindowsHost():
 222         os.environ['GYP_DEFINES'] = 'component=shared_library '\
 223             'incremental_chrome_dll=1 disable_nacl=1 fastbuild=1 '\
 224             'chromium_win_pch=0'
 225
 226   elif build_system == 'make':
 227     os.environ['GYP_GENERATORS'] = 'make'
 228   else:
 229     raise RuntimeError('%s build not supported.' % build_system)
 230
 231   if use_goma:
 232     os.environ['GYP_DEFINES'] = '%s %s' % (os.getenv('GYP_DEFINES', default=''),
 233                                            'use_goma=1')
 234     if goma_dir:
 235       os.environ['GYP_DEFINES'] += ' gomadir=%s' % goma_dir
 236
 237   # Produce 64 bit chromium binaries when target architecure is set to x64.
 238   if target_arch == 'x64':
 239     os.environ['GYP_DEFINES'] += ' target_arch=%s' % target_arch
 240
 241 def SetupPlatformBuildEnvironment(opts):
 242   """Performs any platform-specific setup.
 243
 244   Args:
 245     opts: The options parsed from the command line through parse_args().
 246
 247   Returns:
 248     True if successful.
 249   """
 250   if 'android' in opts.target_platform:
 251     CopyAndSaveOriginalEnvironmentVars()
 252     return SetupAndroidBuildEnvironment(opts)
 253   return True
 254
 255
 256 def BuildWithMake(threads, targets, build_type='Release'):
 257   """Runs a make command with the given targets.
 258
 259   Args:
 260     threads: The number of threads to use. None means unspecified/unlimited.
 261     targets: List of make targets.
 262     build_type: Release or Debug.
 263
 264   Returns:
 265     True if the command had a 0 exit code, False otherwise.
 266   """
 267   cmd = ['make', 'BUILDTYPE=%s' % build_type]
 268   if threads:
 269     cmd.append('-j%d' % threads)
 270   cmd += targets
 271   return_code = bisect_utils.RunProcess(cmd)
 272   return not return_code
 273
 274
 275 def BuildWithNinja(threads, targets, build_type='Release'):
 276   """Runs a ninja command with the given targets."""
 277   cmd = ['ninja', '-C', os.path.join('out', build_type)]
 278   if threads:
 279     cmd.append('-j%d' % threads)
 280   cmd += targets
 281   return_code = bisect_utils.RunProcess(cmd)
 282   return not return_code
 283
 284
 285 def BuildWithVisualStudio(targets, build_type='Release'):
 286   """Runs a command to build the given targets with Visual Studio."""
 287   path_to_devenv = os.path.abspath(
 288       os.path.join(os.environ['VS100COMNTOOLS'], '..', 'IDE', 'devenv.com'))
 289   path_to_sln = os.path.join(os.getcwd(), 'chrome', 'chrome.sln')
 290   cmd = [path_to_devenv, '/build', build_type, path_to_sln]
 291   for t in targets:
 292     cmd.extend(['/Project', t])
 293   return_code = bisect_utils.RunProcess(cmd)
 294   return not return_code
 295
 296
 297 def CopyAndSaveOriginalEnvironmentVars():
 298   """Makes a copy of the current environment variables.
 299
 300   Before making a copy of the environment variables and setting a global
 301   variable, this function unsets a certain set of environment variables.
 302   """
 303   # TODO: Waiting on crbug.com/255689, will remove this after.
 304   vars_to_remove = [
 305       'CHROME_SRC',
 306       'CHROMIUM_GYP_FILE',
 307       'GYP_DEFINES',
 308       'GYP_GENERATORS',
 309       'GYP_GENERATOR_FLAGS',
 310       'OBJCOPY',
 311   ]
 312   for key in os.environ:
 313     if 'ANDROID' in key:
 314       vars_to_remove.append(key)
 315   for key in vars_to_remove:
 316     if os.environ.has_key(key):
 317       del os.environ[key]
 318
 319   global ORIGINAL_ENV
 320   ORIGINAL_ENV = os.environ.copy()
 321
 322
 323 def SetupAndroidBuildEnvironment(opts, path_to_src=None):
 324   """Sets up the android build environment.
 325
 326   Args:
 327     opts: The options parsed from the command line through parse_args().
 328     path_to_src: Path to the src checkout.
 329
 330   Returns:
 331     True if successful.
 332   """
 333   # Revert the environment variables back to default before setting them up
 334   # with envsetup.sh.
 335   env_vars = os.environ.copy()
 336   for k, _ in env_vars.iteritems():
 337     del os.environ[k]
 338   for k, v in ORIGINAL_ENV.iteritems():
 339     os.environ[k] = v
 340
 341   envsetup_path = os.path.join('build', 'android', 'envsetup.sh')
 342   proc = subprocess.Popen(['bash', '-c', 'source %s && env' % envsetup_path],
 343                           stdout=subprocess.PIPE,
 344                           stderr=subprocess.PIPE,
 345                           cwd=path_to_src)
 346   out, _ = proc.communicate()
 347
 348   for line in out.splitlines():
 349     k, _, v = line.partition('=')
 350     os.environ[k] = v
 351
 352   # envsetup.sh no longer sets OS=android in GYP_DEFINES environment variable.
 353   # (See http://crrev.com/170273005). So, we set this variable explicitly here
 354   # in order to build Chrome on Android.
 355   if 'GYP_DEFINES' not in os.environ:
 356     os.environ['GYP_DEFINES'] = 'OS=android'
 357   else:
 358     os.environ['GYP_DEFINES'] += ' OS=android'
 359
 360   if opts.use_goma:
 361     os.environ['GYP_DEFINES'] += ' use_goma=1'
 362   return not proc.returncode