Support for excluding variable from forwarding via forward_variables_form.

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 1311 matching lines @@
   b
   c
 
 
 ```
 ## **forward_variables_from**: Copies variables from a different scope.
 
 ```
   forward_variables_from(from_scope, variable_list_or_star)
 
+  forward_variables_from(from_scope, variable_list_or_star,
+                         variable_to_not_forward_list)
+
   Copies the given variables from the given scope to the local scope
   if they exist. This is normally used in the context of templates to
   use the values of variables defined in the template invocation to
   a template-defined target.
 
   The variables in the given variable_list will be copied if they exist
   in the given scope or any enclosing scope. If they do not exist,
   nothing will happen and they be left undefined in the current scope.
 
   As a special case, if the variable_list is a string with the value of
   "*", all variables from the given scope will be copied. "*" only
   copies variables set directly on the from_scope, not enclosing ones.
   Otherwise it would duplicate all global variables.
 
   When an explicit list of variables is supplied, if the variable exists
   in the current (destination) scope already, an error will be thrown.
   If "*" is specified, variables in the current scope will be
   clobbered (the latter is important because most targets have an
   implicit configs list, which means it wouldn't work at all if it
   didn't clobber).
 
   The sources assignment filter (see "gn help set_sources_assignment_filter")
   is never applied by this function. It's assumed than any desired
   filtering was already done when sources was set on the from_scope.
 
+  The second form of the function allows to give a list of variables not
+  to forward. This is mostly useful when used in combination with "*".
+
 ```
 
 ### **Examples**
 
 ```
   # This is a common action template. It would invoke a script with
   # some given parameters, and wants to use the various types of deps
   # and the visibility from the invoker if it's defined. It also injects
   # an additional dependency to all targets.
   template("my_test") {
     action(target_name) {
       forward_variables_from(invoker, [ "data_deps", "deps",
                                         "public_deps", "visibility" ])
       # Add our test code to the dependencies.
       # "deps" may or may not be defined at this point.
       if (defined(deps)) {
         deps += [ "//tools/doom_melon" ]
       } else {
         deps = [ "//tools/doom_melon" ]
       }
     }
   }
 
   # This is a template around either a target whose type depends on a
   # global variable. It forwards all values from the invoker.
   template("my_wrapper") {
     target(my_wrapper_target_type, target_name) {
       forward_variables_from(invoker, "*")
     }
- }
+  }
+
+  # This is a template around another template that uses a variable to
+  # initialize another variable and is only interested in that one.
+  template("my_ios_test_app") {
+    ios_test_app(target_name) {
+      forward_variables_from(invoker, "*", ["test_bundle_name"])
+      if (!defined(extra_substitutions)) {
+        extra_substitutions = []
+      }
+      extra_substitutions += [ "BUNDLE_ID_TEST_NAME=$test_bundle_name" ]
+    }
+  }
 
 
 ```
 ## **get_label_info**: Get an attribute from a target's label.
 
 ```
   get_label_info(target_label, what)
 
   Given the label of a target, returns some attribute of that target.
   The target need not have been previously defined in the same file,
@@ skipping 3808 matching lines @@
 **  -q**: Quiet mode. Don't print output on success.
 **  \--root**: Explicitly specify source root.
 **  \--runtime-deps-list-file**: Save runtime dependencies for targets in file.
 **  \--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.
 
 ```