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'):

[pkl (ping after 24h if needed), 2014/07/09 08:07:50]

self.spec[type] in (...)

[olivierrobin, 2014/07/09 12:46:27]

Done.

[olivierrobin, 2014/07/09 12:46:27]

Done.

       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":
+      # 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 ' + sdk_root +
+          '/System/Library/PrivateFrameworks/PlugInKit.framework/PlugInKit')
+      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

[pkl (ping after 24h if needed), 2014/07/09 08:07:50]

Use single-quote for strings. Also use "in" operator which is a bit more
concise.

[olivierrobin, 2014/07/09 12:46:27]

Done.

+        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