Add support for user defined "pool" to GN.

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"
+#include "tools/gn/label.h"
+#include "tools/gn/label_ptr.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/tool.h"
 #include "tools/gn/toolchain.h"
 #include "tools/gn/value_extractors.h"
 #include "tools/gn/variables.h"
 
 namespace functions {
@@ skipping 29 matching lines @@
   const Value* v = scope->GetValue(var, true);
   if (!v)
     return true;  // Not present is fine.
   if (!v->VerifyTypeIs(Value::STRING, err))
     return false;
 
   (tool->*set)(v->string_value());
   return true;
 }
 
+// Reads the given label from the scope (if present) and puts the result into
+// dest. If the value is not a label, sets the error and returns false.
+bool ReadLabel(Scope* scope,
+               const char* var,
+               Tool* tool,
+               const ParseNode* origin,
+               const Label& current_toolchain,
+               void (Tool::*set)(const LabelPtrPair<Pool>&),
+               Err* err) {
+  const Value* v = scope->GetValue(var, true);
+  if (!v)
+    return true;  // Not present is fine.
+
+  Label label =
+      Label::Resolve(scope->GetSourceDir(), current_toolchain, *v, err);
+  if (err->has_error())
+    return false;
+
+  LabelPtrPair<Pool> pair(label);
+  pair.origin = origin;
+
+  (tool->*set)(pair);
+  return true;
+}
+
 // Calls the given validate function on each type in the list. On failure,
 // sets the error, blame the value, and return false.
 bool ValidateSubstitutionList(const std::vector<SubstitutionType>& list,
                               bool (*validate)(SubstitutionType),
                               const Value* origin,
                               Err* err) {
   for (const auto& cur_type : list) {
     if (!validate(cur_type)) {
       *err = Err(*origin, "Pattern not valid here.",
           "You used the pattern " + std::string(kSubstitutionNames[cur_type]) +
@@ skipping 441 matching lines @@
     "\n"
     "        Example for a linker tool that produces a .dll and a .lib. The\n"
     "        use of {{target_output_name}}, {{output_extension}} and\n"
     "        {{output_dir}} allows the target to override these values.\n"
     "          outputs = [\n"
     "            \"{{output_dir}}/{{target_output_name}}"
                      "{{output_extension}}\",\n"
     "            \"{{output_dir}}/{{target_output_name}}.lib\",\n"
     "          ]\n"
     "\n"
+    "    pool [label, optional]\n"
+    "\n"
+    "        Label of the pool to use for the tool. Pools are used to limit\n"
+    "        the number of tasks that can execute concurrently during the\n"
+    "        build.\n"
+    "\n"
+    "        See also \"gn help pool\".\n"
+    "\n"
     "    link_output  [string with substitutions]\n"
     "    depend_output  [string with substitutions]\n"
     "    runtime_link_output  [string with substitutions]\n"
     "        Valid for: \"solink\" only (optional)\n"
     "\n"
     "        These three files specify which of the outputs from the solink\n"
     "        tool should be used for linking and dependency tracking. These\n"
     "        should match entries in the \"outputs\". If unspecified, the\n"
     "        first item in the \"outputs\" array will be used for all. See\n"
     "        \"Separate linking and dependencies for shared libraries\"\n"
@@ skipping 370 matching lines @@
                    tool.get(), &Tool::set_runtime_link_output, err) ||
       !ReadString(&block_scope, "output_prefix", tool.get(),
                   &Tool::set_output_prefix, err) ||
       !ReadPattern(&block_scope, "default_output_dir", subst_validator,
                    tool.get(), &Tool::set_default_output_dir, err) ||
       !ReadPrecompiledHeaderType(&block_scope, tool.get(), err) ||
       !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)) {
+                   &Tool::set_rspfile_content, err) ||
+      !ReadLabel(&block_scope, "pool", tool.get(), function, toolchain->label(),
+                 &Tool::set_pool, err)) {
     return Value();
   }
 
   if (tool_type != Toolchain::TYPE_COPY &&
       tool_type != Toolchain::TYPE_STAMP &&
       tool_type != Toolchain::TYPE_COPY_BUNDLE_DATA &&
       tool_type != Toolchain::TYPE_COMPILE_XCASSETS) {
     // All tools should have outputs, except the copy, stamp, copy_bundle_data
     // and compile_xcassets tools that generate their outputs internally.
     if (!ReadOutputs(&block_scope, function, subst_output_validator,
@@ skipping 128 matching lines @@
     return Value();
 
   Scope::KeyValueMap values;
   block_scope.GetCurrentScopeValues(&values);
   toolchain->args() = values;
 
   return Value();
 }
 
 }  // namespace functions