Support explicit pools in actions

tools/gn/function_toolchain.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "tools/gn/err.h"
 #include "tools/gn/functions.h"
@@ skipping 513 matching lines @@
       "asm": Assembler
 
     Linker tools:
       "alink": Linker for static libraries (archives)
       "solink": Linker for shared libraries
       "link": Linker for executables
 
     Other tools:
       "stamp": Tool for creating stamp files
       "copy": Tool to copy files.
+      "action": Defaults for actions
 
     Platform specific tools:
       "copy_bundle_data": [iOS, OS X] Tool to copy files in a bundle.
       "compile_xcassets": [iOS, OS X] Tool to compile asset catalogs.
 
 Tool variables
 
     command  [string with substitutions]
-        Valid for: all tools (required)
+        Valid for: all tools except "action" (required)
 
         The command to run.
 
     default_output_dir  [string with substitutions]
         Valid for: linker tools
 
         Default directory name for the output file relative to the
         root_build_dir. It can contain other substitution patterns. This will
         be the default value for the {{output_dir}} expansion (discussed below)
         but will be overridden by the "output_dir" variable in a target, if one
@@ skipping 79 matching lines @@
         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]
+        Valid for: all tools (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]
         Valid for: "solink" only (optional)
 
@@ skipping 50 matching lines @@
 
         Normally, Ninja will assume that when a tool runs the output be new and
         downstream dependents must be rebuild. When this is set to trye, Ninja
         can skip rebuilding downstream dependents for input changes that don't
         actually affect the output.
 
         Example:
           restat = true
 
     rspfile  [string with substitutions]
-        Valid for: all tools (optional)
+        Valid for: all tools except "action" (optional)
 
         Name of the response file. If empty, no response file will be
         used. See "rspfile_content".
 
     rspfile_content  [string with substitutions]
-        Valid for: all tools (required when "rspfile" is specified)
+        Valid for: all tools except "action" (required when "rspfile" is used)
 
         The contents to be written to the response file. This may include all
         or part of the command to send to the tool which 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"
@@ skipping 315 matching lines @@
       !ReadBool(&block_scope, "restat", tool.get(), &Tool::set_restat, err) ||
       !ReadPattern(&block_scope, "rspfile", subst_validator, tool.get(),
                    &Tool::set_rspfile, err) ||
       !ReadPattern(&block_scope, "rspfile_content", subst_validator, tool.get(),
                    &Tool::set_rspfile_content, err) ||
       !ReadLabel(&block_scope, "pool", tool.get(), toolchain->label(),
                  &Tool::set_pool, err)) {
     return Value();
   }
 
-  if (tool_type != Toolchain::TYPE_COPY &&
-      tool_type != Toolchain::TYPE_STAMP &&
+  if (tool_type != Toolchain::TYPE_COPY && tool_type != Toolchain::TYPE_STAMP &&
       tool_type != Toolchain::TYPE_COPY_BUNDLE_DATA &&
-      tool_type != Toolchain::TYPE_COMPILE_XCASSETS) {
+      tool_type != Toolchain::TYPE_COMPILE_XCASSETS &&
+      tool_type != Toolchain::TYPE_ACTION) {
     // All tools should have outputs, except the copy, stamp, copy_bundle_data
-    // and compile_xcassets tools that generate their outputs internally.
+    // compile_xcassets and action tools that generate their outputs internally.
     if (!ReadPatternList(&block_scope, "outputs", subst_output_validator,
                          tool.get(), &Tool::set_outputs, err) ||
         !ValidateOutputs(tool.get(), err))
       return Value();
   }
   if (!ValidateRuntimeOutputs(tool.get(), tool_type, err))
     return Value();
 
   // Validate link_output and depend_output.
   if (!ValidateLinkAndDependOutput(tool.get(), tool_type, tool->link_output(),
@@ skipping 11 matching lines @@
 
   // Make sure there weren't any vars set in this tool that were unused.
   if (!block_scope.CheckForUnusedVars(err))
     return Value();
 
   toolchain->SetTool(tool_type, std::move(tool));
   return Value();
 }
 
 }  // namespace functions