Add support for customizing GN's args text.

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 from
@@ skipping 3875 matching lines @@
   primary object(s) of the build. It will match the OS of the default
   toolchain.
 
   In many cases, this is the same as "host_os", but in the case of
   cross-compiles, it may be different. This variable differs from "current_os"
   in that it can be referenced from inside any toolchain and will always return
   the initial value.
 
   This should be set to the most specific value possible. So, "android" or
   "chromeos" should be used instead of "linux" where applicable, even though
-  Android and Chrome OS are both Linux variants. This can mean that one needs to
+  Android and ChromeOS are both Linux variants. This can mean that one needs to
   write
 
       if (target_os == "android" || target_os == "linux") {
           # ...
       }
 
   and so forth.
 
   This value is not used internally by GN for any purpose, so it may be set to
   whatever value is needed for the build. GN defaults this value to the empty
@@ skipping 1393 matching lines @@
 
 
 ```
 ## **precompiled_header**: [string] Header file to precompile.
 
 ```
   Precompiled headers will be used when a target specifies this value, or a
   config applying to this target specifies this value. In addition, the tool
   corresponding to the source files must also specify precompiled headers (see
   "gn help tool"). The tool will also specify what type of precompiled headers
-  to use.
+  to use, by setting precompiled_header_type to either "gcc" or "msvc".
 
   The precompiled header/source variables can be specified on a target or a
   config, but must be the same for all configs applying to a given target since
   a target can only have one precompiled header.
 
+  If you use both C and C++ sources, the precompiled header and source file
+  will be compiled once per language. You will want to make sure to wrap C++
+  includes in __cplusplus #ifdefs so the file will compile in C mode.
+
+```
+
+### **GCC precompiled headers**
+
+```
+  When using GCC-style precompiled headers, "precompiled_source" contains the
+  path of a .h file that is precompiled and then included by all source files
+  in targets that set "precompiled_source".
+
+  The value of "precompiled_header" is not used with GCC-style precompiled
+  headers.
+
 ```
 
 ### **MSVC precompiled headers**
 
 ```
   When using MSVC-style precompiled headers, the "precompiled_header" value is
   a string corresponding to the header. This is NOT a path to a file that GN
-  recognises, but rather the exact string that appears in quotes after an
-  #include line in source code. The compiler will match this string against
+  recognises, but rather the exact string that appears in quotes after
+  an #include line in source code. The compiler will match this string against
   includes or forced includes (/FI).
 
   MSVC also requires a source file to compile the header with. This must be
   specified by the "precompiled_source" value. In contrast to the header value,
   this IS a GN-style file name, and tells GN which source file to compile to
   make the .pch file used for subsequent compiles.
 
-  If you use both C and C++ sources, the precompiled header and source file
-  will be compiled using both tools. You will want to make sure to wrap C++
-  includes in __cplusplus #ifdefs so the file will compile in C mode.
-
   For example, if the toolchain specifies MSVC headers:
 
     toolchain("vc_x64") {
       ...
       tool("cxx") {
         precompiled_header_type = "msvc"
         ...
 
   You might make a config like this:
 
     config("use_precompiled_headers") {
       precompiled_header = "build/precompile.h"
       precompiled_source = "//build/precompile.cc"
 
       # Either your source files should #include "build/precompile.h"
       # first, or you can do this to force-include the header.
       cflags = [ "/FI$precompiled_header" ]
     }
 
   And then define a target that uses the config:
 
     executable("doom_melon") {
       configs += [ ":use_precompiled_headers" ]
       ...
 
 
 ```
+## **precompiled_header_type**: [string] "gcc" or "msvc".
+
+```
+  See "gn help precompiled_header".
+
+
+```
 ## **precompiled_source**: [file name] Source file to precompile.
 
 ```
   The source file that goes along with the precompiled_header when using
   "msvc"-style precompiled headers. It will be implicitly added to the sources
   of the target. See "gn help precompiled_header".
 
 
 ```
 ## **product_type**: Product type for Xcode projects.
@@ skipping 416 matching lines @@
   directory. If you want to specify a different file, you can additionally pass
   --dotfile:
 
     gn gen out/Debug --root=/home/build --dotfile=/home/my_gn_file.gn
 
 ```
 
 ### **Variables**
 
 ```
+  arg_file_template [optional]
+      Path to a file containing the text that should be used as the default
+      args.gn content when you run `gn args`.
+
   buildconfig [required]
-      Label of the build config file. This file will be used to set up the
+      Path to the build config file. This file will be used to set up the
       build file execution environment for each toolchain.
 
   check_targets [optional]
       A list of labels and label patterns that should be checked when running
       "gn check" or "gn gen --check". If unspecified, all targets will be
       checked. If it is the empty list, no targets will be checked.
 
       The format of this list is identical to that of "visibility" so see "gn
       help visibility" for examples.
 
@@ skipping 854 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.
 
 ```