Add support for iOS Frameworks with header maps.

pylib/gyp/generator/ninja.py

 # Copyright (c) 2013 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.
 
 import collections
 import copy
 import hashlib
 import json
 import multiprocessing
 import os.path
@@ skipping 541 matching lines @@
     if 'rules' in spec:
       outputs += self.WriteRules(spec['rules'], extra_sources, prebuild,
                                  mac_bundle_resources,
                                  extra_mac_bundle_resources)
     if 'copies' in spec:
       outputs += self.WriteCopies(spec['copies'], prebuild, mac_bundle_depends)
 
     if 'sources' in spec and self.flavor == 'win':
       outputs += self.WriteWinIdlFiles(spec, prebuild)
 
+    if self.xcode_settings.IsIosFramework():
+      self.WriteiOSFrameworkHeaders(spec, outputs, prebuild)
+
     stamp = self.WriteCollapsedDependencies('actions_rules_copies', outputs)
 
     if self.is_mac_bundle:
       xcassets = self.WriteMacBundleResources(
           extra_mac_bundle_resources + mac_bundle_resources, mac_bundle_depends)
       partial_info_plist = self.WriteMacXCassets(xcassets, mac_bundle_depends)
       self.WriteMacInfoPlist(partial_info_plist, mac_bundle_depends)
 
     return stamp
 
@@ skipping 163 matching lines @@
                          implicit=inputs,
                          order_only=prebuild,
                          variables=extra_bindings)
 
         all_outputs.extend(outputs)
 
     return all_outputs
 
   def WriteCopies(self, copies, prebuild, mac_bundle_depends):
     outputs = []
-    env = self.GetToolchainEnv()
+    extra_env = self.xcode_settings.GetPerTargetSettings()
+    env = self.GetToolchainEnv(additional_settings=extra_env)
     for copy in copies:
       for path in copy['files']:
         # Normalize the path so trailing slashes don't confuse us.
         path = os.path.normpath(path)
         basename = os.path.split(path)[1]
         src = self.GypPathToNinja(path, env)
         dst = self.GypPathToNinja(os.path.join(copy['destination'], basename),
                                   env)
         outputs += self.ninja.build(dst, 'copy', src, order_only=prebuild)
         if self.is_mac_bundle:
           # gyp has mac_bundle_resources to copy things into a bundle's
           # Resources folder, but there's no built-in way to copy files to other
           # places in the bundle. Hence, some targets use copies for this. Check
           # if this file is copied into the current bundle, and if so add it to
           # the bundle depends so that dependent targets get rebuilt if the copy
           # input changes.
           if dst.startswith(self.xcode_settings.GetBundleContentsFolderPath()):
             mac_bundle_depends.append(dst)
 
     return outputs
 
+  def WriteiOSFrameworkHeaders(self, spec, outputs, prebuild):
+    """Prebuild steps to generate hmap files and copy headers to destination."""
+    framework = self.ComputeMacBundleOutput()
+    all_sources = spec['sources']
+    copy_headers = spec['mac_framework_headers']
+    output = self.GypPathToUniqueOutput('headers.hmap')
+    self.xcode_settings.header_map_path = output
+    all_headers = map(self.GypPathToNinja,
+                      filter(lambda x:x.endswith(('.h')), all_sources))
+    variables = [('framework', framework),
+                 ('copy_headers', map(self.GypPathToNinja, copy_headers))]
+    outputs.extend(self.ninja.build(
+        output, 'compile_ios_framework_headers', all_headers,
+        variables=variables, order_only=prebuild))
+
   def WriteMacBundleResources(self, resources, bundle_depends):
     """Writes ninja edges for 'mac_bundle_resources'."""
     xcassets = []
 
     extra_env = self.xcode_settings.GetPerTargetSettings()
     env = self.GetSortedXcodeEnv(additional_settings=extra_env)
     env = self.ComputeExportEnvString(env)
     isBinary = self.xcode_settings.IsBinaryOutputFormat(self.config_name)
 
     for output, res in gyp.xcode_emulation.GetMacBundleResources(
@@ skipping 554 matching lines @@
   def WriteMacBundle(self, spec, mac_bundle_depends, is_empty):
     assert self.is_mac_bundle
     package_framework = spec['type'] in ('shared_library', 'loadable_module')
     output = self.ComputeMacBundleOutput()
     if is_empty:
       output += '.stamp'
     variables = []
     self.AppendPostbuildVariable(variables, spec, output, self.target.binary,
                                  is_command_start=not package_framework)
     if package_framework and not is_empty:
-      variables.append(('version', self.xcode_settings.GetFrameworkVersion()))
-      self.ninja.build(output, 'package_framework', mac_bundle_depends,
-                       variables=variables)
+      if spec['type'] == 'shared_library' and self.xcode_settings.isIOS:
+        self.ninja.build(output, 'package_ios_framework', mac_bundle_depends)
+      else:
+        variables.append(('version', self.xcode_settings.GetFrameworkVersion()))
+        self.ninja.build(output, 'package_framework', mac_bundle_depends,
+                         variables=variables)
     else:
       self.ninja.build(output, 'stamp', mac_bundle_depends,
                        variables=variables)
     self.target.bundle = output
     return output
 
   def GetToolchainEnv(self, additional_settings=None):
     """Returns the variables toolchain would set for build steps."""
     env = self.GetSortedXcodeEnv(additional_settings=additional_settings)
     if self.flavor == 'win':
@@ skipping 881 matching lines @@
       command='$env ./gyp-mac-tool copy-info-plist $in $out $binary $keys')
     master_ninja.rule(
       'merge_infoplist',
       description='MERGE INFOPLISTS $in',
       command='$env ./gyp-mac-tool merge-info-plist $out $in')
     master_ninja.rule(
       'compile_xcassets',
       description='COMPILE XCASSETS $in',
       command='$env ./gyp-mac-tool compile-xcassets $keys $in')
     master_ninja.rule(
+      'compile_ios_framework_headers',
+      description='COMPILE HEADER MAPS AND COPY FRAMEWORK HEADER $in',
+      command='$env ./gyp-mac-tool compile-ios-framework-header-map $out '
+              '$framework $in && $env ./gyp-mac-tool '
+              'copy-ios-framework-headers $framework $copy_headers')
+    master_ninja.rule(
       'mac_tool',
       description='MACTOOL $mactool_cmd $in',
       command='$env ./gyp-mac-tool $mactool_cmd $in $out $binary')
     master_ninja.rule(
       'package_framework',
       description='PACKAGE FRAMEWORK $out, POSTBUILDS',
       command='./gyp-mac-tool package-framework $out $version$postbuilds '
               '&& touch $out')
+    master_ninja.rule(
+      'package_ios_framework',
+      description='PACKAGE IOS FRAMEWORK $out, POSTBUILDS',
+      command='./gyp-mac-tool package-ios-framework $out $postbuilds '
+              '&& touch $out')
   if flavor == 'win':
     master_ninja.rule(
       'stamp',
       description='STAMP $out',
       command='%s gyp-win-tool stamp $out' % sys.executable)
     master_ninja.rule(
       'copy',
       description='COPY $in $out',
       command='%s gyp-win-tool recursive-mirror $in $out' % sys.executable)
   else:
@@ skipping 155 matching lines @@
           arglists.append(
               (target_list, target_dicts, data, params, config_name))
         pool.map(CallGenerateOutputForConfig, arglists)
       except KeyboardInterrupt, e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data, params,
                                 config_name)