ninja/mac: Support iOS codesign for ninja builds.

pylib/gyp/xcode_emulation.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 This module contains classes that help to emulate xcodebuild behavior on top of
 other build systems, such as make and ninja.
 """
 
 import copy
 import gyp.common
 import os.path
 import re
 import shlex
 import subprocess
 import sys
 from gyp.common import GypError
 
 class XcodeSettings(object):
   """A class that understands the gyp 'xcode_settings' object."""
 
   # Populated lazily by _SdkPath(). Shared by all XcodeSettings, so cached
   # at class-level for efficiency.
   _sdk_path_cache = {}
 
   # Populated lazily by GetExtraPlistItems(). Shared by all XcodeSettings, so
   # cached at class-level for efficiency.
   _plist_cache = {}
 
+  # Populated lazily by GetIOSPostbuilds.  Shared by all XcodeSettings, so
+  # cached at class-level for efficiency.
+  _codesigning_key_cache = {}
+
   def __init__(self, spec):
     self.spec = spec
 
     self.isIOS = False
 
     # Per-target 'xcode_settings' are pushed down into configs earlier by gyp.
     # This means self.xcode_settings[config] always contains all settings
     # for that config -- the per-target settings as well. Settings that are
     # the same for all configs are implicitly per-target settings.
     self.xcode_settings = {}
     configs = spec['configurations']
     for configname, config in configs.iteritems():
       self.xcode_settings[configname] = config.get('xcode_settings', {})
+      self._ConvertConditionalKeys(configname)
       if self.xcode_settings[configname].get('IPHONEOS_DEPLOYMENT_TARGET',
                                              None):
         self.isIOS = True
 
-      # If you need this, speak up at http://crbug.com/122592
-      conditional_keys = [key for key in self.xcode_settings[configname]
-                          if key.endswith(']')]
-      if conditional_keys:
-        print 'Warning: Conditional keys not implemented, ignoring:', \
-              ' '.join(conditional_keys)
-        for key in conditional_keys:
-          del self.xcode_settings[configname][key]
-
     # This is only non-None temporarily during the execution of some methods.
     self.configname = None
 
     # Used by _AdjustLibrary to match .a and .dylib entries in libraries.
     self.library_re = re.compile(r'^lib([^/]+)\.(a|dylib)$')
 
+  def _ConvertConditionalKeys(self, configname):
+    """Converts or warns on conditional keys.  Xcode supports conditional keys,
+    such as CODE_SIGN_IDENTITY[sdk=iphoneos*].  This is a partial implementation
+    with some keys converted while the rest force a warning."""
+    settings = self.xcode_settings[configname]
+    conditional_keys = [key for key in settings if key.endswith(']')]
+    for key in conditional_keys:
+      # If you need more, speak up at http://crbug.com/122592
+      if key.endswith("[sdk=iphoneos*]"):
+        if configname.endswith("iphoneos"):
+          new_key = key.split("[")[0]
+          settings[new_key] = settings[key]
+      else:
+        print 'Warning: Conditional keys not implemented, ignoring:', \
+              ' '.join(conditional_keys)
+      del settings[key]
+
   def _Settings(self):
     assert self.configname
     return self.xcode_settings[self.configname]
 
   def _Test(self, test_key, cond_key, default):
     return self._Settings().get(test_key, default) == cond_key
 
   def _Appendf(self, lst, test_key, format_str, default=None):
     if test_key in self._Settings():
       lst.append(format_str % str(self._Settings()[test_key]))
@@ skipping 665 matching lines @@
         self._Test(
             'DEBUG_INFORMATION_FORMAT', 'dwarf-with-dsym', default='dwarf') and
         self.spec['type'] != 'static_library'):
       if not quiet:
         result.append('echo DSYMUTIL\\(%s\\)' % self.spec['target_name'])
       result.append('dsymutil %s -o %s' % (output_binary, output + '.dSYM'))
 
     self.configname = None
     return result
 
-  def GetTargetPostbuilds(self, configname, output, output_binary, quiet=False):
+  def _GetTargetPostbuilds(self, configname, output, output_binary,
+                           quiet=False):
     """Returns a list of shell commands that contain the shell commands
     to run as postbuilds for this target, before the actual postbuilds."""
     # dSYMs need to build before stripping happens.
     return (
         self._GetDebugInfoPostbuilds(configname, output, output_binary, quiet) +
         self._GetStripPostbuilds(configname, output_binary, quiet))
 
+  def _GetIOSPostbuilds(self, configname, output_binary):
+    """Return a shell command to codesign the iOS output binary so it can
+    be deployed to a device.  This should be run as the very last step of the
+    build."""
+    if not (self.isIOS and self.spec['type'] == "executable"):
+      return []
+
+    identity = self.xcode_settings[configname].get('CODE_SIGN_IDENTITY', '')
+    if identity == '':
+      return []
+    if identity not in XcodeSettings._codesigning_key_cache:
+      proc = subprocess.Popen(['security', 'find-identity', '-p', 'codesigning',
+                               '-v'], stdout=subprocess.PIPE)
+      output = proc.communicate()[0].strip()
+      key = None
+      for item in output.split("\n"):
+        if identity in item:
+          assert key == None, (
+              "Multiple codesigning identities for identity: %s" %
+              identity)
+          key = item.split(' ')[1]
+      XcodeSettings._codesigning_key_cache[identity] = key
+    key = XcodeSettings._codesigning_key_cache[identity]
+    if key:
+      # Warn for any unimplemented signing xcode keys.
+      unimpl = ['CODE_SIGN_RESOURCE_RULES_PATH', 'OTHER_CODE_SIGN_FLAGS',
+                'CODE_SIGN_ENTITLEMENTS']
+      keys = set(self.xcode_settings[configname].keys())
+      unimpl = set(unimpl) & keys
+      if unimpl:
+        print 'Warning: Some codesign keys not implemented, ignoring:', \
+            ' '.join(unimpl)
+      return ['codesign --force --sign %s %s' % (key, output_binary)]
+    return []
+
+  def AddImplicitPostbuilds(self, configname, output, output_binary,
+                            postbuilds=[], quiet=False):
+    """Returns a list of shell commands that should run before and after
+    |postbuilds|."""
+    assert output_binary is not None
+    pre = self._GetTargetPostbuilds(configname, output, output_binary, quiet)
+    post = self._GetIOSPostbuilds(configname, output_binary)
+    return pre + postbuilds + post
+
   def _AdjustLibrary(self, library, config_name=None):
     if library.endswith('.framework'):
       l = '-framework ' + os.path.splitext(os.path.basename(library))[0]
     else:
       m = self.library_re.match(library)
       if m:
         l = '-l' + m.group(1)
       else:
         l = library
     return l.replace('$(SDKROOT)', self._SdkPath(config_name))
@@ skipping 43 matching lines @@
 
       sdk_root = self._SdkRoot(configname)
       cache['DTSDKName'] = sdk_root
       if xcode >= '0430':
         cache['DTSDKBuild'] = self._GetSdkVersionInfoItem(
             sdk_root, 'ProductBuildVersion')
       else:
         cache['DTSDKBuild'] = cache['BuildMachineOSBuild']
 
       if self.isIOS:
-        cache['UIDeviceFamily'] = self._XcodeIOSDeviceFamily(configname)
         if configname.endswith("iphoneos"):
           cache['CFBundleSupportedPlatforms'] = ['iPhoneOS']
         else:
           cache['CFBundleSupportedPlatforms'] = ['iPhoneSimulator']
       XcodeSettings._plist_cache[configname] = cache
-    return XcodeSettings._plist_cache[configname]
+
+    # Include extra plist items that are per-target, not per global
+    # XcodeSettings.
+    items = dict(XcodeSettings._plist_cache[configname])
+    if self.isIOS:
+      items['UIDeviceFamily'] = self._XcodeIOSDeviceFamily(configname)
+    return items
 
 
 class MacPrefixHeader(object):
   """A class that helps with emulating Xcode's GCC_PREFIX_HEADER feature.
 
   This feature consists of several pieces:
   * If GCC_PREFIX_HEADER is present, all compilations in that project get an
     additional |-include path_to_prefix_header| cflag.
   * If GCC_PRECOMPILE_PREFIX_HEADER is present too, then the prefix header is
     instead compiled, and all other compilations in the project get an
@@ skipping 392 matching lines @@
         new_config_dict['xcode_settings']['SDKROOT'] = 'iphoneos'
       target_dict['configurations'][new_config_name] = new_config_dict
   return targets
 
 def CloneConfigurationForDeviceAndEmulator(target_dicts):
   """If |target_dicts| contains any iOS targets, automatically create -iphoneos
   targets for iOS device builds."""
   if _HasIOSTarget(target_dicts):
     return _AddIOSDeviceConfigurations(target_dicts)
   return target_dicts