Adds the ability to skip includes.

pylib/gyp/generator/ninja.py

 # Copyright (c) 2013 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.
 
 import copy
 import hashlib
 import json
 import multiprocessing
 import os.path
 import re
@@ skipping 194 matching lines @@
 # - GypPathToNinja translates a gyp path (i.e. relative to the .gyp file)
 #   into the equivalent ninja path.
 #
 # - GypPathToUniqueOutput translates a gyp path into a ninja path to write
 #   an output file; the result can be namespaced such that it is unique
 #   to the input file name as well as the output target name.
 
 class NinjaWriter:
   def __init__(self, qualified_target, target_outputs, base_dir, build_dir,
                output_file, toplevel_build, output_file_name, flavor,
-               deps_file=None, toplevel_dir=None):
+               toplevel_dir=None):
     """
     base_dir: path from source root to directory containing this gyp file,
               by gyp semantics, all input paths are relative to this
     build_dir: path from source root to build output
     toplevel_dir: path to the toplevel directory
     """
 
     self.qualified_target = qualified_target
     self.target_outputs = target_outputs
     self.base_dir = base_dir
@@ skipping 13 matching lines @@
       self.win_env = {}
       for arch in ('x86', 'x64'):
         self.win_env[arch] = 'environment.' + arch
 
     # Relative path from build output dir to base dir.
     build_to_top = gyp.common.InvertRelativePath(build_dir, toplevel_dir)
     self.build_to_base = os.path.join(build_to_top, base_dir)
     # Relative path from base dir to build dir.
     base_to_top = gyp.common.InvertRelativePath(base_dir, toplevel_dir)
     self.base_to_build = os.path.join(base_to_top, build_dir)
-    self.link_deps_file = deps_file
 
   def ExpandSpecial(self, path, product_dir=None):
     """Expand specials like $!PRODUCT_DIR in |path|.
 
     If |product_dir| is None, assumes the cwd is already the product
     dir.  Otherwise, |product_dir| is the relative path to the product
     dir.
     """
 
     PRODUCT_DIR = '$!PRODUCT_DIR'
@@ skipping 718 matching lines @@
       # - Linkable dependencies (like a .a or a .so): add them to the link line.
       # - Non-linkable dependencies (like a rule that generates a file
       #   and writes a stamp file): add them to implicit_deps
       extra_link_deps = set()
       for dep in spec['dependencies']:
         target = self.target_outputs.get(dep)
         if not target:
           continue
         linkable = target.Linkable()
         if linkable:
-          if self.link_deps_file:
-            # Save the mapping of link deps.
-            self.link_deps_file.write(self.qualified_target)
-            self.link_deps_file.write(' ')
-            self.link_deps_file.write(target.binary)
-            self.link_deps_file.write('\n')
-
           new_deps = []
           if (self.flavor == 'win' and
               target.component_objs and
               self.msvs_settings.IsUseLibraryDependencyInputs(config_name)):
             new_deps = target.component_objs
           elif self.flavor == 'win' and target.import_lib:
             new_deps = [target.import_lib]
           elif target.UsesToc(self.flavor):
             solibs.add(target.binary)
             implicit_deps.add(target.binary + '.TOC')
@@ skipping 1004 matching lines @@
                                         os.path.normpath(build_file)):
       all_targets.add(target)
   all_outputs = set()
 
   # target_outputs is a map from qualified target name to a Target object.
   target_outputs = {}
   # target_short_names is a map from target short name to a list of Target
   # objects.
   target_short_names = {}
 
-  # Extract the optional link deps file name.
-  LINK_DEPS_FILE = 'link_deps_file'
-  if LINK_DEPS_FILE in generator_flags:
-    link_deps_file = open(generator_flags.get(LINK_DEPS_FILE), 'wb')
-  else:
-    link_deps_file = None
-
   for qualified_target in target_list:
     # qualified_target is like: third_party/icu/icu.gyp:icui18n#target
     build_file, name, toolset = \
         gyp.common.ParseQualifiedTarget(qualified_target)
 
     this_make_global_settings = data[build_file].get('make_global_settings', [])
     assert make_global_settings == this_make_global_settings, (
         "make_global_settings needs to be the same for all targets.")
 
     spec = target_dicts[qualified_target]
     if flavor == 'mac':
       gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
 
     build_file = gyp.common.RelativePath(build_file, options.toplevel_dir)
 
     base_path = os.path.dirname(build_file)
     obj = 'obj'
     if toolset != 'target':
       obj += '.' + toolset
     output_file = os.path.join(obj, base_path, name + '.ninja')
 
     ninja_output = StringIO()
     writer = NinjaWriter(qualified_target, target_outputs, base_path, build_dir,
                          ninja_output,
                          toplevel_build, output_file,
-                         flavor, link_deps_file,
-                         toplevel_dir=options.toplevel_dir)
+                         flavor, toplevel_dir=options.toplevel_dir)
 
     target = writer.WriteSpec(spec, config_name, generator_flags)
 
     if ninja_output.tell() > 0:
       # Only create files for ninja files that actually have contents.
       with OpenOutput(os.path.join(toplevel_build, output_file)) as ninja_file:
         ninja_file.write(ninja_output.getvalue())
       ninja_output.close()
       master_ninja.subninja(output_file)
 
@@ skipping 62 matching lines @@
           arglists.append(
               (target_list, target_dicts, data, params, config_name))
         pool.map(CallGenerateOutputForConfig, arglists)
       except KeyboardInterrupt, e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data, params,
                                 config_name)