Rework iOS recipes to use latest MB approach

scripts/slave/recipe_modules/ios/api.py

 # Copyright 2015 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 copy
 
 from recipe_engine import recipe_api
 
 
 class iOSApi(recipe_api.RecipeApi):
@@ skipping 33 matching lines @@
   def compiler(self):
     assert self.__config is not None
     return self.__config['compiler']
 
   @property
   def configuration(self):
     assert self.__config is not None
     return self.__config['configuration']
 
   @property
+  def using_gyp(self):
+    assert self.__config is not None
+    return not self.using_mb or self.__config.get('mb_type') == 'gyp'
+
+  @property
+  def using_mb(self):
+    assert self.__config is not None
+    # MB and GN only work if we're doing ninja builds, so we will
+    # ignore the mb_type setting if compiler isn't set to ninja.
+    return self.__config['mb_type'] is not None and self.compiler == 'ninja'
+
+  @property
   def platform(self):
     assert self.__config is not None
     if self.__config['sdk'].startswith('iphoneos'):
       return 'device'
     elif self.__config['sdk'].startswith('iphonesimulator'):
       return 'simulator'
 
   def read_build_config(
     self,
     master_name=None,
@@ skipping 47 matching lines @@
 
       for key in (
         'xcode version',
         'GYP_DEFINES',
         'compiler',
         'configuration',
         'sdk',
       ):
         self.__config[key] = parent_config[key]
 
-    # We set some default GYP_DEFINES so developers don't have to set them
-    # manually on every bot. Add them in here.
-    self.__config['GYP_DEFINES']['component'] = 'static_library'
-    self.__config['GYP_DEFINES']['OS'] = 'ios'
+    # In the older dict-based bot configs we didn't set these values
+    # since they were the same on every bot. In the newer configs they
+    # are set anyway since MB needs them as well.
+    if isinstance(self.__config['GYP_DEFINES'], dict):
+      self.__config['GYP_DEFINES']['component'] = 'static_library'
+      self.__config['GYP_DEFINES']['OS'] = 'ios'
 
     # TODO(crbug.com/552146): Once 'all' works, the default should be ['all'].
     self.__config.setdefault('additional_compile_targets', ['All'])
-    self.__config.setdefault('use_mb', False)
 
     # In order to simplify the code that uses the values of self.__config, here
     # we default to empty values of their respective types, so in other places
     # we can iterate over them without having to check if they are in the dict
     # at all.
     self.__config['triggered bots'] = self.__config.get('triggered bots', {})
     self.__config['tests'] = self.__config.get('tests', [])
     self.__config['env'] = self.__config.get('env', {})
 
+    self.__config.setdefault('mb_type', None)
+
     # Elements of the "tests" list are dicts. There are two types of elements,
     # determined by the presence of one of these mutually exclusive keys:
     #   "app": This says to run a particular app.
     #   "include": This says to include a common set of tests from include_dir.
     # So now we go through the "tests" list replacing any "include" keys.
     # The value of an "include" key is the name of a set of tests to include,
     # which can be found as a .json file in include_dir. Read the contents
     # lazily as needed into includes.
     def read_include(includes):
       """Reads the contents of the given include.
@@ skipping 53 matching lines @@
         'scripts',
         'slave',
         'ios',
         'find_xcode.py',
       ),
       '--json-file', self.m.json.output(),
       '--version', self.__config['xcode version'],
     ], step_test_data=lambda: self.m.json.test_api.output({}))
 
     cfg = self.m.chromium.make_config()
-    cfg.gyp_env.GYP_CROSSCOMPILE = 1
-    cfg.gyp_env.GYP_DEFINES = copy.deepcopy(self.__config['GYP_DEFINES'])
+
+    if self.using_gyp:
+      cfg.gyp_env.GYP_CROSSCOMPILE = 1
+      cfg.gyp_env.GYP_DEFINES = copy.deepcopy(self.__config['GYP_DEFINES'])
     self.m.chromium.c = cfg
 
   def build(self, suffix=None):
     """Builds from this bot's build config."""
     assert self.__config is not None
 
     suffix = ' (%s)' % suffix if suffix else ''
 
-    # MB and GN only work if we're doing ninja builds, so we will
-    # ignore the use_mb setting if compiler isn't set to ninja.
-    use_mb = self.__config['use_mb'] and self.compiler == 'ninja'
-    if use_mb:
+    if self.using_mb:
       self.m.chromium.c.project_generator.tool = 'mb'
 
     # Add the default GYP_DEFINES.
-    gyp_defines = [
-      '%s=%s' % (k, v) for k, v in self.__config['GYP_DEFINES'].iteritems()
-    ]
+    if isinstance(self.__config['GYP_DEFINES'], dict):
+      gyp_defines = [
+        '%s=%s' % (k, v) for k, v in self.__config['GYP_DEFINES'].iteritems()
+      ]
+    else:
+      gyp_defines = self.__config['GYP_DEFINES']
 
     env = {
       'GYP_DEFINES': ' '.join(gyp_defines),
       'LANDMINES_VERBOSE': '1',
     }
 
     # Add extra env variables.
     env.update(self.__config['env'])
 
     sub_path = ''
@@ skipping 15 matching lines @@
       env['GYP_CROSSCOMPILE'] = '1'
       env['GYP_GENERATORS'] = 'ninja'
       sub_path = '%s-%s' % (self.configuration, {
           'simulator': 'iphonesimulator',
           'device': 'iphoneos',
         }[self.platform])
 
       cwd = self.m.path['checkout'].join('out', sub_path)
       cmd = ['ninja', '-C', cwd]
 
-    if use_mb:
+    if self.using_mb:
       # if we're using MB to generate build files, make sure we don't
       # invoke GYP directly. We still want the GYP_DEFINES set in the
       # environment, though, so that other hooks can key off of them.
       env['GYP_CHROMIUM_NO_ACTION'] = '1'
 
     step_result = self.m.gclient.runhooks(name='runhooks' + suffix, env=env)
     step_result.presentation.step_text = (
       '<br />GYP_DEFINES:<br />%s' % '<br />'.join(gyp_defines)
     )
+    if self.using_mb:
+      step_result.presentation.step_text += '<br />GYP_CHROMIUM_NO_ACTION=1'
 
-    if use_mb:
+    if self.using_mb:
       self.m.chromium.run_mb(self.m.properties['mastername'],
                              self.m.properties['buildername'],
                              name='generate_build_files' + suffix,
                              build_dir='//out/' + sub_path)

[Dirk Pranke, 2015/11/18 04:28:34]

We could present the GYP_DEFINES and/or gn_args and mb_type values in the step
text for this step as well.

Only logging the GYP_DEFINES after runhooks might be somewhat misleading for the
bots that use MB and/or GN.

[smut, 2015/11/19 20:58:50]

Sure.

 
     if (self.compiler == 'ninja' and
         self.m.tryserver.is_tryserver and
         'without patch' not in suffix):
       affected_files = self.m.tryserver.get_files_affected_by_patch()
       # The same test may be configured to run on multiple simulators.
       # Only specify each test once for the analyzer.
       tests = list(set(test['app'] for test in self.__config['tests']))
 
       requires_compile, test_targets, compile_targets = (
@@ skipping 162 matching lines @@
         self.configuration,
         'iossim',
       ),
       'ninja': self.m.path.join(
         'src',
          build_dir,
          '%s-%s' % (self.configuration, platform),
          'iossim',
       ),
     }[self.compiler]