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')
+    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]