This CL adds support for extension in GYP.

pylib/gyp/input.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.
 
 from compiler.ast import Const
 from compiler.ast import Dict
 from compiler.ast import Discard
 from compiler.ast import List
 from compiler.ast import Module
 from compiler.ast import Node
@@ skipping 10 matching lines @@
 import subprocess
 import sys
 import threading
 import time
 import traceback
 from gyp.common import GypError
 from gyp.common import OrderedSet
 
 
 # A list of types that are treated as linkable.
-linkable_types = ['executable', 'shared_library', 'loadable_module']
+linkable_types = [
+  'executable',
+  'shared_library',
+  'loadable_module',
+  'extension'
+]
 
 # A list of sections that contain links to other targets.
 dependency_sections = ['dependencies', 'export_dependent_settings']
 
 # base_path_sections is a list of sections defined by GYP that contain
 # pathnames.  The generators can provide more keys, the two lists are merged
 # into path_sections, but you should call IsPathSection instead of using either
 # list directly.
 base_path_sections = [
   'destination',
@@ skipping 1654 matching lines @@
       # dependencies are intended to apply to the target itself (initial is
       # True) and this target won't be linked.
       return dependencies
 
     # Don't traverse 'none' targets if explicitly excluded.
     if (target_type == 'none' and
         not targets[self.ref].get('dependencies_traverse', True)):
       dependencies.add(self.ref)
       return dependencies
 
-    # Executables and loadable modules are already fully and finally linked.
-    # Nothing else can be a link dependency of them, there can only be
-    # dependencies in the sense that a dependent target might run an
+    # Executables, loadable modules, and extensions are already fully and
+    # finally linked.  Nothing else can be a link dependency of them, there can
+    # only be dependencies in the sense that a dependent target might run an
     # executable or load the loadable_module.
-    if not initial and target_type in ('executable', 'loadable_module'):
+    FULLY_LINKED_TYPES = ('executable', 'loadable_module', 'extension')

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

This is just a "normal" local variable. It should be just fully_linked_types
(not all caps). I'm aware that there are other cases in this file that has all
caps local variables...they are wrong too (thought you are not expected to fix
them).

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

Done.

+    if not initial and target_type in FULLY_LINKED_TYPES:
       return dependencies
 
     # Shared libraries are already fully linked.  They should only be included
     # in |dependencies| when adjusting static library dependencies (in order to
     # link against the shared_library's import lib), but should not be included
     # in |dependencies| when propagating link_settings.
     # The |include_shared_libraries| flag controls which of these two cases we
     # are handling.
     if (not initial and target_type == 'shared_library' and
         not include_shared_libraries):
@@ skipping 722 matching lines @@
   """Ensures the 'type' field on the target is one of the known types.
 
   Arguments:
     target: string, name of target.
     target_dict: dict, target spec.
 
   Raises an exception on error.
   """
   VALID_TARGET_TYPES = ('executable', 'loadable_module',
                         'static_library', 'shared_library',
-                        'none')
+                        'extension', 'none')
   target_type = target_dict.get('type', None)
   if target_type not in VALID_TARGET_TYPES:
     raise GypError("Target %s has an invalid target type '%s'.  "
                    "Must be one of %s." %
                    (target, target_type, '/'.join(VALID_TARGET_TYPES)))
   if (target_dict.get('standalone_static_library', 0) and
       not target_type == 'static_library'):
     raise GypError('Target %s has type %s but standalone_static_library flag is'
                    ' only valid for static_library type.' % (target,
                                                              target_type))
@@ skipping 387 matching lines @@
     ValidateRunAsInTarget(target, target_dict, build_file)
     ValidateActionsInTarget(target, target_dict, build_file)
 
   # Generators might not expect ints.  Turn them into strs.
   TurnIntIntoStrInDict(data)
 
   # TODO(mark): Return |data| for now because the generator needs a list of
   # build files that came in.  In the future, maybe it should just accept
   # a list, and not the whole data dict.
   return [flat_list, targets, data]