This CL adds support for extension in GYP.

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
@@ skipping 200 matching lines @@
     elif default:
       lst.append(format_str % str(default))
 
   def _WarnUnimplemented(self, test_key):
     if test_key in self._Settings():
       print 'Warning: Ignoring not yet implemented key "%s".' % test_key
 
   def _IsBundle(self):
     return int(self.spec.get('mac_bundle', 0)) != 0
 
+  def _IsIosAppExtension(self):
+    return int(self.spec.get('ios_app_extension', 0)) != 0
+
   def GetFrameworkVersion(self):
     """Returns the framework version of the current target. Only valid for
     bundles."""
     assert self._IsBundle()
     return self.GetPerTargetSetting('FRAMEWORK_VERSION', default='A')
 
   def GetWrapperExtension(self):
     """Returns the bundle extension (.app, .framework, .plugin, etc).  Only
     valid for bundles."""
     assert self._IsBundle()
     if self.spec['type'] in ('loadable_module', 'shared_library'):
       default_wrapper_extension = {
         'loadable_module': 'bundle',
         'shared_library': 'framework',
       }[self.spec['type']]
       wrapper_extension = self.GetPerTargetSetting(
           'WRAPPER_EXTENSION', default=default_wrapper_extension)
       return '.' + self.spec.get('product_extension', wrapper_extension)
     elif self.spec['type'] == 'executable':
-      return '.' + self.spec.get('product_extension', 'app')
+      if self._IsIosAppExtension():
+        return '.' + self.spec.get('product_extension', 'appex')
+      else:
+        return '.' + self.spec.get('product_extension', 'app')
     else:
       assert False, "Don't know extension for '%s', target '%s'" % (
           self.spec['type'], self.spec['target_name'])
 
   def GetProductName(self):
     """Returns PRODUCT_NAME."""
     return self.spec.get('product_name', self.spec['target_name'])
 
   def GetFullProductName(self):
     """Returns FULL_PRODUCT_NAME."""
@@ skipping 34 matching lines @@
     Chromium.app/Contents/Info.plist. Only valid for bundles."""
     assert self._IsBundle()
     if self.spec['type'] in ('executable', 'loadable_module'):
       return os.path.join(self.GetBundleContentsFolderPath(), 'Info.plist')
     else:
       return os.path.join(self.GetBundleContentsFolderPath(),
                           'Resources', 'Info.plist')
 
   def GetProductType(self):
     """Returns the PRODUCT_TYPE of this target."""
+    if self._IsIosAppExtension():
+      assert self._IsBundle(), ('ios_app_extension flag requires mac_bundle '
+          '(target %s)' % self.spec['target_name'])
+      return 'com.apple.product-type.app-extension'
     if self._IsBundle():
       return {
         'executable': 'com.apple.product-type.application',
         'loadable_module': 'com.apple.product-type.bundle',
         'shared_library': 'com.apple.product-type.framework',
       }[self.spec['type']]
     else:
       return {
         'executable': 'com.apple.product-type.tool',
         'loadable_module': 'com.apple.product-type.library.dynamic',
@@ skipping 482 matching lines @@
       ldflags.append('-Wl,-rpath,' + rpath)
 
     sdk_root = self._SdkPath()
     if not sdk_root:
       sdk_root = ''
     config = self.spec['configurations'][self.configname]
     framework_dirs = config.get('mac_framework_dirs', [])
     for directory in framework_dirs:
       ldflags.append('-F' + directory.replace('$(SDKROOT)', sdk_root))
 
+    if sdk_root and self._IsIosAppExtension():
+      # Adds the link flags for extensions. These flags are common for all
+      # extensions and provide loader and main function.
+      # These flags reflect the compilation options used by xcode to compile
+      # extensions.
+      ldflags.append('-lpkstart')
+      ldflags.append(sdk_root +
+          '/System/Library/PrivateFrameworks/PlugInKit.framework/PlugInKit')
+      ldflags.append('-fapplication-extension')
+      ldflags.append('-Xlinker -rpath '
+          '-Xlinker @executable_path/../../Frameworks')
+
     self._Appendf(ldflags, 'CLANG_CXX_LIBRARY', '-stdlib=%s')
 
     self.configname = None
     return ldflags
 
   def GetLibtoolflags(self, configname):
     """Returns flags that need to be passed to the static linker.
 
     Args:
         configname: The name of the configuration to get ld flags for.
@@ skipping 107 matching lines @@
     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"):
+    if not (self.isIOS and self.spec['type'] == 'executable'):
       return []
 
     settings = self.xcode_settings[configname]
     key = self._GetIOSCodeSignIdentityKey(settings)
     if not key:
       return []
 
     # Warn for any unimplemented signing xcode keys.
     unimpl = ['OTHER_CODE_SIGN_FLAGS']
     unimpl = set(unimpl) & set(self.xcode_settings[configname].keys())
@@ skipping 615 matching lines @@
       if toolset == 'target':
         iphoneos_config_dict['xcode_settings']['SDKROOT'] = 'iphoneos'
   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