Add bundle_deps_filter to create_bundle targets.

tools/gn/docs/reference.md

 # GN Reference
 
 *This page is automatically generated from* `gn help --markdown all`.
 
 ## **\--args**: Specifies build arguments overrides.
 
 ```
   See "gn help buildargs" for an overview of how build arguments work.
 
   Most operations take a build directory. The build arguments are taken
@@ skipping 428 matching lines @@
 
 ```
 ## **gn clean <out_dir>**
 
 ```
   Deletes the contents of the output directory except for args.gn and
   creates a Ninja build environment sufficient to regenerate the build.
 
 
 ```
-## **gn desc <out_dir> <label or pattern> [<what to show>] [\--blame]**
+## **gn desc <out_dir> <label or pattern> [<what to show>] [\--blame] [\--format=json]**
 
 ```
   Displays information about a given target or config. The build
   build parameters will be taken for the build in the given <out_dir>.
 
   The <label or pattern> can be a target label, a config label, or a
   label pattern (see "gn help label_pattern"). A label pattern will
   only match targets.
 
 ```
@@ skipping 45 matching lines @@
 ```
   --all-toolchains
       Normally only inputs in the default toolchain will be included.
       This switch will turn on matching all toolchains.
 
       For example, a file is in a target might be compiled twice:
       once in the default toolchain and once in a secondary one. Without
       this flag, only the default toolchain one will be matched by
       wildcards. With this flag, both will be matched.
 
+  --format=json
+      Format the output as JSON instead of text.
+
 ```
 
 ### **Target flags**
 
 ```
   --blame
       Used with any value specified on a config, this will name
       the config that cause that target to get the flag. This doesn't
       currently work for libs and lib_dirs because those are inherited
       and are more complicated to figure out the blame (patches
@@ skipping 170 matching lines @@
 
   --ide=<ide_name>
       Generate files for an IDE. Currently supported values:
       "eclipse" - Eclipse CDT settings file.
       "vs" - Visual Studio project/solution files.
              (default Visual Studio version: 2015)
       "vs2013" - Visual Studio 2013 project/solution files.
       "vs2015" - Visual Studio 2015 project/solution files.
       "xcode" - Xcode workspace/solution files.
       "qtcreator" - QtCreator project files.
+      "json" - JSON file containing target information
 
   --filters=<path_prefixes>
       Semicolon-separated list of label patterns used to limit the set
       of generated projects (see "gn help label_pattern"). Only
       matching targets and their dependencies will be included in the
-      solution. Only used for Visual Studio and Xcode.
+      solution. Only used for Visual Studio, Xcode and JSON.
 
 ```
 
 ### **Visual Studio Flags**
 
 ```
   --sln=<file_name>
       Override default sln file name ("all"). Solution file is written
       to the root build directory.
 
@@ skipping 34 matching lines @@
 ```
   GN DOES NOT generate Eclipse CDT projects. Instead, it generates a
   settings file which can be imported into an Eclipse CDT project. The
   XML file contains a list of include paths and defines. Because GN does
   not generate a full .cproject definition, it is not possible to
   properly define includes/defines for each file individually.
   Instead, one set of includes/defines is generated for the entire
   project. This works fairly well but may still result in a few indexer
   issues here and there.
 
+```
+
+### **Generic JSON Output**
+
+```
+  Dumps target information to JSON file and optionally invokes python
+  script on generated file.
+
+  See comments at the beginning of json_project_writer.cc and
+  desc_builder.cc for overview of JSON file format.
+
+  --json-file-name=<json_file_name>
+      Overrides default file name (project.json) of generated JSON file.
+
+  --json-ide-script=<path_to_python_script>
+      Executes python script after the JSON file is generated.
+      Path can be project absolute (//), system absolute (/) or
+      relative, in which case the output directory will be base.
+      Path to generated JSON file will be first argument when invoking
+      script.
+
+  --json-ide-script-args=<argument>
+      Optional second argument that will passed to executed script.
+
 
 ```
 ## **gn help <anything>**
 
 ```
   Yo dawg, I heard you like help on your help so I put help on the help
   in the help.
 
   You can also use "all" as the parameter to get all help at once.
 
@@ skipping 520 matching lines @@
 
 ### **Examples**
 
 ```
   bundle_data("icudata") {
     sources = [ "sources/data/in/icudtl.dat" ]
     outputs = [ "{{bundle_resources_dir}}/{{source_file_part}}" ]
   }
 
   bundle_data("base_unittests_bundle_data]") {
-    sources = [ "test/data" ]

+    sources = [ "test/data" ]
     outputs = [
       "{{bundle_resources_dir}}/{{source_root_relative_dir}}/" +
           "{{source_file_part}}"
     ]
   }
 
   bundle_data("material_typography_bundle_data") {
     sources = [
       "src/MaterialTypography.bundle/Roboto-Bold.ttf",
       "src/MaterialTypography.bundle/Roboto-Italic.ttf",
@@ skipping 145 matching lines @@
   The code_signing_args will be passed as is to the script (so path have
   to be rebased) and additional inputs may be listed with the variable
   code_signing_sources.
 
 ```
 
 ### **Variables**
 
 ```
   bundle_root_dir*, bundle_resources_dir*, bundle_executable_dir*,
-  bundle_plugins_dir*, deps, data_deps, public_deps, visibility,
-  product_type, code_signing_args, code_signing_script,
+  bundle_plugins_dir*, bundle_deps_filter, deps, data_deps, public_deps,
+  visibility, product_type, code_signing_args, code_signing_script,
   code_signing_sources, code_signing_outputs
   * = required
 
 ```
 
 ### **Example**
 
 ```
   # Defines a template to create an application. On most platform, this
   # is just an alias for an "executable" target, but on iOS/OS X, it
@@ skipping 1541 matching lines @@
         at least one output file. There can be more than one output (a
         linker might produce a library and an import library, for
         example).
 
         This array just declares to GN what files the tool will
         produce. It is your responsibility to specify the tool command
         that actually produces these files.
 
         If you specify more than one output for shared library links,
         you should consider setting link_output, depend_output, and
-        runtime_link_output. Otherwise, the first entry in the
-        outputs list should always be the main output which will be
-        linked to.
+        runtime_outputs.
 
         Example for a compiler tool that produces .obj files:
           outputs = [
             "{{source_out_dir}}/{{source_name_part}}.obj"
           ]
 
         Example for a linker tool that produces a .dll and a .lib. The
         use of {{target_output_name}}, {{output_extension}} and
         {{output_dir}} allows the target to override these values.
           outputs = [
             "{{output_dir}}/{{target_output_name}}{{output_extension}}",
             "{{output_dir}}/{{target_output_name}}.lib",
           ]
 
     pool [label, optional]
 
         Label of the pool to use for the tool. Pools are used to limit
         the number of tasks that can execute concurrently during the
         build.
 
         See also "gn help pool".
 
     link_output  [string with substitutions]
     depend_output  [string with substitutions]
-    runtime_link_output  [string with substitutions]
         Valid for: "solink" only (optional)
 
-        These three files specify which of the outputs from the solink
+        These two files specify which of the outputs from the solink
         tool should be used for linking and dependency tracking. These
         should match entries in the "outputs". If unspecified, the
         first item in the "outputs" array will be used for all. See
         "Separate linking and dependencies for shared libraries"
-        below for more. If link_output is set but runtime_link_output
-        is not set, runtime_link_output defaults to link_output.
+        below for more.
 
         On Windows, where the tools produce a .dll shared library and
         a .lib import library, you will want the first two to be the
         import library and the third one to be the .dll file.
         On Linux, if you're not doing the separate linking/dependency
         optimization, all of these should be the .so output.
 
     output_prefix  [string]
         Valid for: Linker tools (optional)
 
@@ skipping 56 matching lines @@
         allows you to get around OS command-line length limits.
 
         This example adds the inputs and libraries to a response file,
         but passes the linker flags directly on the command line:
           tool("link") {
             command = "link -o {{output}} {{ldflags}} @{{output}}.rsp"
             rspfile = "{{output}}.rsp"
             rspfile_content = "{{inputs}} {{solibs}} {{libs}}"
           }
 
+    runtime_outputs  [string list with substitutions]
+        Valid for: linker tools
+
+        If specified, this list is the subset of the outputs that should
+        be added to runtime deps (see "gn help runtime_deps"). By
+        default (if runtime_outputs is empty or unspecified), it will be
+        the link_output.
+
 ```
 
 ### **Expansions for tool variables**
 
 ```
   All paths are relative to the root build directory, which is the
   current directory for running all tools. These expansions are
   available to all tools:
 
     {{label}}
@@ skipping 1645 matching lines @@
   propagated across all types of targets, and public_configs
   are always propagated across public deps of all types of targets.
 
   Data dependencies are propagated differently. See
   "gn help data_deps" and "gn help runtime_deps".
 
   See also "public_deps".
 
 
 ```
+## **bundle_deps_filter**: [label list] A list of labels that are filtered out.
+
+```
+  A list of target labels.
+
+  This list contains target label patterns that should be filtered out
+  when creating the bundle. Any target matching one of those label will
+  be removed from the dependencies of the create_bundle target.
+
+  This is mostly useful when creating application extension bundle as
+  the application extension has access to runtime resources from the
+  application bundle and thus do not require a second copy.
+
+  See "gn help create_bundle" for more information.
+
+```
+
+### **Example**
+
+```
+  create_bundle("today_extension") {
+    deps = [
+      "//base"
+    ]
+    bundle_root_dir = "$root_out_dir/today_extension.appex"
+    bundle_deps_filter = [
+      # The extension uses //base but does not use any function calling
+      # into third_party/icu and thus does not need the icudtl.dat file.
+      "//third_party/icu:icudata",
+    ]
+  }
+
+
+```
 ## **include_dirs**: Additional include directories.
 
 ```
   A list of source directories.
 
   The directories in this list will be added to the include path for
   the files in the affected target.
 
 ```
 
@@ skipping 1328 matching lines @@
   targets only. If you need to list a static library as a runtime
   dependency, you can manually compute the .a/.lib file name for the
   current platform and list it in the "data" list of a target
   (possibly on the static library target itself).
 
 ```
 
 ### **Multiple outputs**
 
 ```
-  When a tool produces more than one output, only the first output
-  is considered. For example, a shared library target may produce a
-  .dll and a .lib file on Windows. Only the .dll file will be considered
-  a runtime dependency. This applies only to linker tools. Scripts and
-  copy steps with multiple outputs will get all outputs listed.
+  Linker tools can specify which of their outputs should be considered
+  when computing the runtime deps by setting runtime_outputs. If this
+  is unset on the tool, the default will be the first output only.
 
 
 ```
 ## **How Source Expansion Works**
 
 ```
   Source expansion is used for the action_foreach and copy target types
   to map source file names to output file names or arguments.
 
   To perform source expansion in the outputs, GN maps every entry in the
@@ skipping 127 matching lines @@
 **  \--root**: Explicitly specify source root.
 **  \--runtime-deps-list-file**: Save runtime dependencies for targets in file.
 **  \--script-executable**: Set the executable used to execute scripts.
 **  \--threads**: Specify number of worker threads.
 **  \--time**: Outputs a summary of how long everything took.
 **  \--tracelog**: Writes a Chrome-compatible trace log to the given file.
 **  -v**: Verbose logging.
 **  \--version**: Prints the GN version number and exits.
 
 ```