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 220 matching lines @@
     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')
+    elif self.spec['type'] == 'extension':
+      return '.' + self.spec.get('product_extension', 'appex')
     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 26 matching lines @@
     Chromium.app/Contents/Resources. Only valid for bundles."""
     assert self._IsBundle()
     if self.isIOS:
       return self.GetBundleContentsFolderPath()
     return os.path.join(self.GetBundleContentsFolderPath(), 'Resources')
 
   def GetBundlePlistPath(self):
     """Returns the qualified path to the bundle's plist file. E.g.
     Chromium.app/Contents/Info.plist. Only valid for bundles."""
     assert self._IsBundle()
-    if self.spec['type'] in ('executable', 'loadable_module'):
+    if self.spec['type'] in ('executable', 'extension', '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._IsBundle():
       return {
         'executable': 'com.apple.product-type.application',
+        'extension': 'com.apple.product-type.app-extension',
         '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',
+        'extension': 'com.apple.product-type.app-extension',
         'loadable_module': 'com.apple.product-type.library.dynamic',
         'shared_library': 'com.apple.product-type.library.dynamic',
         'static_library': 'com.apple.product-type.library.static',
       }[self.spec['type']]
 
   def GetMachOType(self):
     """Returns the MACH_O_TYPE of this target."""
     # Weird, but matches Xcode.
-    if not self._IsBundle() and self.spec['type'] == 'executable':
+    if not self._IsBundle() and (self.spec['type'] == 'executable' or
+        self.spec['type'] == 'extension'):
       return ''
     return {
       'executable': 'mh_execute',
+      'extension': 'mh_execute',
       'static_library': 'staticlib',
       'shared_library': 'mh_dylib',
       'loadable_module': 'mh_bundle',
     }[self.spec['type']]
 
   def _GetBundleBinaryPath(self):
     """Returns the name of the bundle binary of by this target.
     E.g. Chromium.app/Contents/MacOS/Chromium. Only valid for bundles."""
     assert self._IsBundle()
     if self.spec['type'] in ('shared_library') or self.isIOS:
       path = self.GetBundleContentsFolderPath()
-    elif self.spec['type'] in ('executable', 'loadable_module'):
+    elif self.spec['type'] in ('executable', 'extension', 'loadable_module'):
       path = os.path.join(self.GetBundleContentsFolderPath(), 'MacOS')
     return os.path.join(path, self.GetExecutableName())
 
   def _GetStandaloneExecutableSuffix(self):
     if 'product_extension' in self.spec:
       return '.' + self.spec['product_extension']
     return {
       'executable': '',
+      'extension': '',
       'static_library': '.a',
       'shared_library': '.dylib',
       'loadable_module': '.so',
     }[self.spec['type']]
 
   def _GetStandaloneExecutablePrefix(self):
     return self.spec.get('product_prefix', {
       'executable': '',
+      'extension': '',
       'static_library': 'lib',
       'shared_library': 'lib',
       # Non-bundled loadable_modules are called foo.so for some reason
       # (that is, .so and no prefix) with the xcode build -- match that.
       'loadable_module': '',
     }[self.spec['type']])
 
   def _GetStandaloneBinaryPath(self):
     """Returns the name of the non-bundle binary represented by this target.
     E.g. hello_world. Only valid for non-bundles."""
     assert not self._IsBundle()
-    assert self.spec['type'] in (
-        'executable', 'shared_library', 'static_library', 'loadable_module'), (
+    assert self.spec['type'] in ('executable', 'extension', 'shared_library',
+        'static_library', 'loadable_module'), (
         'Unexpected type %s' % self.spec['type'])
     target = self.spec['target_name']
     if self.spec['type'] == 'static_library':
       if target[:3] == 'lib':
         target = target[3:]
     elif self.spec['type'] in ('loadable_module', 'shared_library'):
       if target[:3] == 'lib':
         target = target[3:]
 
     target_prefix = self._GetStandaloneExecutablePrefix()
@@ skipping 420 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.spec['type'] == "extension":
+      ldflags.append('-lpkstart ' + sdk_root +
+          '/System/Library/PrivateFrameworks/PlugInKit.framework/PlugInKit')

[justincohen, 2014/07/07 14:13:58]

Maybe a comment on why this has to be hard coded, and maybe tips on how to find
the new path and update this one when inevitably Apple changes the private
framework path somehow

[olivierrobin, 2014/07/07 14:36:35]

Done.

+      ldflags.append('-fapplication-extension ' +
+          '-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 56 matching lines @@
 
     result = []
     if (self._Test('DEPLOYMENT_POSTPROCESSING', 'YES', default='NO') and
         self._Test('STRIP_INSTALLED_PRODUCT', 'YES', default='NO')):
 
       default_strip_style = 'debugging'
       if self.spec['type'] == 'loadable_module' and self._IsBundle():
         default_strip_style = 'non-global'
       elif self.spec['type'] == 'executable':
         default_strip_style = 'all'
+      elif self.spec['type'] == 'extension':
+        default_strip_style = 'all'
 
       strip_style = self._Settings().get('STRIP_STYLE', default_strip_style)
       strip_flags = {
         'all': '',
         'non-global': '-x',
         'debugging': '-S',
       }[strip_style]
 
       explicit_strip_flags = self._Settings().get('STRIPFLAGS', '')
       if explicit_strip_flags:
@@ skipping 31 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" or
+        self.spec['type'] == "extension")):
       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 460 matching lines @@
     # written for bundles:
     'TARGET_BUILD_DIR' : built_products_dir,
     'TEMP_DIR' : '${TMPDIR}',
   }
   if xcode_settings.GetPerConfigSetting('SDKROOT', configuration):
     env['SDKROOT'] = xcode_settings._SdkPath(configuration)
   else:
     env['SDKROOT'] = ''
 
   if spec['type'] in (
-      'executable', 'static_library', 'shared_library', 'loadable_module'):
+      'executable',
+      'extension',
+      'static_library',
+      'shared_library',
+      'loadable_module'):
     env['EXECUTABLE_NAME'] = xcode_settings.GetExecutableName()
     env['EXECUTABLE_PATH'] = xcode_settings.GetExecutablePath()
     env['FULL_PRODUCT_NAME'] = xcode_settings.GetFullProductName()
     mach_o_type = xcode_settings.GetMachOType()
     if mach_o_type:
       env['MACH_O_TYPE'] = mach_o_type
     env['PRODUCT_TYPE'] = xcode_settings.GetProductType()
   if xcode_settings._IsBundle():
     env['CONTENTS_FOLDER_PATH'] = \
       xcode_settings.GetBundleContentsFolderPath()
@@ skipping 134 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