build: use class path bases, not strings

scripts/slave/recipe_modules/chromium/config.py

 # Copyright 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.
 
 import pipes
 
 from recipe_engine.config import config_item_context, ConfigGroup
 from recipe_engine.config import Dict, List, Single, Static, Set, BadConf
 from recipe_engine.config_types import Path
 
@@ skipping 11 matching lines @@
 MEMORY_TOOLS = ('memcheck', 'drmemory_full', 'drmemory_light')
 PROJECT_GENERATORS = ('gyp', 'gn', 'mb')
 
 def check(val, potentials):
   assert val in potentials, (val, potentials)
   return val
 
 # Schema for config items in this module.
 def BaseConfig(HOST_PLATFORM, HOST_ARCH, HOST_BITS,
                TARGET_PLATFORM, TARGET_ARCH, TARGET_BITS,
-               BUILD_CONFIG, TARGET_CROS_BOARD, **_kwargs):
+               BUILD_CONFIG, TARGET_CROS_BOARD,
+               BUILD_PATH, CHECKOUT_PATH, **_kwargs):
   equal_fn = lambda tup: ('%s=%s' % (tup[0], pipes.quote(str(tup[1]))))
   return ConfigGroup(
     compile_py = ConfigGroup(
       default_targets = Set(basestring),
       build_args = Single(basestring, required=False),
       build_tool = Single(basestring, required=False),
       cross_tool = Single(basestring, required=False),
       compiler = Single(basestring, required=False),
       mode = Single(basestring, required=False),
       goma_dir = Single(Path, required=False),
@@ skipping 60 matching lines @@
 
     HOST_PLATFORM = Static(check(HOST_PLATFORM, HOST_PLATFORMS)),
     HOST_ARCH = Static(check(HOST_ARCH, HOST_ARCHS)),
     HOST_BITS = Static(check(HOST_BITS, HOST_TARGET_BITS)),
 
     TARGET_PLATFORM = Static(check(TARGET_PLATFORM, TARGET_PLATFORMS)),
     TARGET_ARCH = Static(check(TARGET_ARCH, TARGET_ARCHS)),
     TARGET_BITS = Static(check(TARGET_BITS, HOST_TARGET_BITS)),
     TARGET_CROS_BOARD = Static(TARGET_CROS_BOARD),
 
+    BUILD_PATH = Static(BUILD_PATH),
+    CHECKOUT_PATH = Static(CHECKOUT_PATH),
+
     gn_args = List(basestring),
 
     lto = Single(bool, empty_val=False, required=False),
   )
 
 config_ctx = config_item_context(BaseConfig)
 
 
 @config_ctx(is_root=True)
 def BASE(c):
@@ skipping 36 matching lines @@
   if c.HOST_BITS < c.TARGET_BITS:
     raise BadConf('host bits < targ bits')  # pragma: no cover
 
   c.build_config_fs = c.BUILD_CONFIG
   if c.HOST_PLATFORM == 'win':
     if c.TARGET_BITS == 64:
       # Windows requires 64-bit builds to be in <dir>_x64.
       c.build_config_fs = c.BUILD_CONFIG + '_x64'
 
   # Test runner memory tools that are not compile-time based.
-  c.runtests.memory_tests_runner = Path('[CHECKOUT]', 'tools', 'valgrind',
-                                        'chrome_tests',
-                                        platform_ext={'win': '.bat',
-                                                      'mac': '.sh',
-                                                      'linux': '.sh'})
+  c.runtests.memory_tests_runner = c.CHECKOUT_PATH.join(
+      'tools', 'valgrind', 'chrome_tests',
+      platform_ext={'win': '.bat', 'mac': '.sh', 'linux': '.sh'})
 
   if c.project_generator.tool not in PROJECT_GENERATORS:  # pragma: no cover
     raise BadConf('"%s" is not a supported project generator tool, the '
                   'supported ones are: %s' % (c.project_generator.tool,
                                               ','.join(PROJECT_GENERATORS)))
   gyp_arch = {
     ('intel', 32): 'ia32',
     ('intel', 64): 'x64',
     ('arm',   32): 'arm',
     ('arm',   64): 'arm64',
@@ skipping 42 matching lines @@
 @config_ctx(group='builder')
 def ninja(c):
   if c.TARGET_PLATFORM == 'ios':
     c.gyp_env.GYP_GENERATORS.add('ninja')
 
   c.compile_py.build_tool = 'ninja'
 
   out_path = 'out'
   if c.TARGET_CROS_BOARD:
     out_path += '_%s' % (c.TARGET_CROS_BOARD,)
-  c.build_dir = Path('[CHECKOUT]', out_path)
+  c.build_dir = c.CHECKOUT_PATH.join(out_path)
 
 @config_ctx()
 def msvs2010(c):
   c.gyp_env.GYP_MSVS_VERSION = '2010'
 
 @config_ctx()
 def msvs2012(c):
   c.gyp_env.GYP_MSVS_VERSION = '2012'
 
 @config_ctx()
@@ skipping 57 matching lines @@
 
   if not c.compile_py.compiler:
     c.compile_py.compiler = 'goma'
   elif c.compile_py.compiler == 'clang':
     c.compile_py.compiler = 'goma-clang'
   else:  # pragma: no cover
     raise BadConf('goma config doesn\'t understand %s' % c.compile_py.compiler)
 
   c.gyp_env.GYP_DEFINES['use_goma'] = 1
 
-  goma_dir = Path('[BUILD]', 'goma')
+  goma_dir = c.BUILD_PATH.join('goma')
   c.gyp_env.GYP_DEFINES['gomadir'] = goma_dir
   c.compile_py.goma_dir = goma_dir
 
   if c.TARGET_PLATFORM == 'win' and c.compile_py.compiler != 'goma-clang':
     fastbuild(c)
     pch(c, invert=True)
 
 @config_ctx()
 def pch(c, invert=False):
   if c.TARGET_PLATFORM == 'win':
@@ skipping 344 matching lines @@
   c.compile_py.default_targets = ['All', 'chromium_builder_tests']
 
 @config_ctx(includes=['ninja', 'clang', 'cfi_vptr'])
 def chromium_cfi(c):
   c.compile_py.default_targets = ['All']
 
 @config_ctx(includes=['xcode', 'static_library'])
 def chromium_xcode(c):  # pragma: no cover
   c.compile_py.build_tool = 'xcode'
   c.compile_py.default_targets = ['All']
-  c.compile_py.xcode_project = Path('[CHECKOUT]', 'build', 'all.xcodeproj')
+  c.compile_py.xcode_project = c.CHECKOUT_PATH.join('build', 'all.xcodeproj')
 
 @config_ctx(includes=['chromium', 'official'])
 def chromium_official(c):
   # TODO(phajdan.jr): Unify compile targets used by official builders.
   if c.TARGET_PLATFORM == 'win':
     c.compile_py.default_targets = ['chrome_official_builder']
   elif c.TARGET_PLATFORM in ['linux', 'mac']:
     c.compile_py.default_targets = []
 
 @config_ctx(includes=['chromium'])
@@ skipping 28 matching lines @@
   # See https://www.chromium.org/developers/testing/addresssanitizer.
   pass
 
 @config_ctx()
 def android_common(c):
   gyp_defs = c.gyp_env.GYP_DEFINES
   gyp_defs['fastbuild'] = 1
   gyp_defs['OS'] = 'android'
 
   c.env.PATH.extend([
-      Path('[CHECKOUT]', 'third_party', 'android_tools', 'sdk',
-           'platform-tools'),
-      Path('[CHECKOUT]', 'build', 'android')])
+      c.CHECKOUT_PATH.join(
+          'third_party', 'android_tools', 'sdk', 'platform-tools'),
+      c.CHECKOUT_PATH.join('build', 'android')])
 
 @config_ctx()
 def android_findbugs(c):
   c.gyp_env.GYP_DEFINES['run_findbugs'] = 1
 
 @config_ctx(includes=['ninja', 'shared_library', 'clang', 'goma'])
 def codesearch(c):
   # -k 0 prevents stopping on errors, so the compile step tries to do as much as
   # possible.
   c.compile_py.build_args = '-k 0'
@@ skipping 52 matching lines @@
 def internal_gles2_conform_tests(c):
   c.gyp_env.GYP_DEFINES['internal_gles2_conform_tests'] = 1
 
 @config_ctx()
 def build_angle_deqp_tests(c):
   c.gyp_env.GYP_DEFINES['build_angle_deqp_tests'] = 1
 
 @config_ctx()
 def force_mac_toolchain(c):
   c.env.FORCE_MAC_TOOLCHAIN = 1