Support explicit pools in actions

tools/gn/functions.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 "tools/gn/functions.h"
 
 #include <stddef.h>
 #include <iostream>
 #include <utility>
 
@@ skipping 715 matching lines @@
     R"*(pool: Defines a pool object.
 
   Pool objects can be applied to a tool to limit the parallelism of the
   build. This object has a single property "depth" corresponding to
   the number of tasks that may run simultaneously.
 
   As the file containing the pool definition may be executed in the
   context of more than one toolchain it is recommended to specify an
   explicit toolchain when defining and referencing a pool.
 
+  A pool marked "console = true" will use the built-in ninja "console"
+  pool and cannot specify "depth" which is always 1.
+
   A pool is referenced by its label just like a target.
 
 Variables
 
-  depth*
+  console, depth*
   * = required
 
 Example
 
   if (current_toolchain == default_toolchain) {
     pool("link_pool") {
       depth = 1
     }
   }
 
@@ skipping 17 matching lines @@
 
   if (!EnsureSingleStringArg(function, args, err) ||
       !EnsureNotProcessingImport(function, scope, err))
     return Value();
 
   Label label(MakeLabelForScope(scope, function, args[0].string_value()));
 
   if (g_scheduler->verbose_logging())
     g_scheduler->Log("Defining pool", label.GetUserVisibleName(true));
 
-  // Get the pool depth. It is an error to define a pool without a depth,
-  // so check first for the presence of the value.
-  const Value* depth = scope->GetValue(kDepth, true);
-  if (!depth) {
-    *err = Err(function, "Can't define a pool without depth.");
-    return Value();
+  // Create the new pool.
+  std::unique_ptr<Pool> pool(new Pool(scope->settings(), label));
+
+  // Check the value of console.
+  const Value* console = scope->GetValue(variables::kConsole, true);
+  if (console) {
+    if (!console->VerifyTypeIs(Value::BOOLEAN, err))
+      return Value();
   }
 
-  if (!depth->VerifyTypeIs(Value::INTEGER, err))
-    return Value();
+  // Get the pool depth. Pool must hae a depth or be a console pool.
+  const Value* depth = scope->GetValue(kDepth, true);
+  if (console && console->boolean_value()) {
+    if (depth) {
+      *err = Err(function, "Can't define a console pool with depth.");
+      return Value();
+    }
 
-  if (depth->int_value() < 0) {
-    *err = Err(function, "depth must be positive or nul.");
-    return Value();
+    pool->set_console(console->boolean_value());
+  } else {
+    if (!depth) {
+      *err = Err(function, "Can't define a pool without depth.");
+      return Value();
+    }
+
+    if (!depth->VerifyTypeIs(Value::INTEGER, err))
+      return Value();
+
+    if (depth->int_value() < 0) {
+      *err = Err(function, "depth must be positive or nul.");
+      return Value();
+    }
+
+    pool->set_depth(depth->int_value());
   }
 
-  // Create the new pool.
-  std::unique_ptr<Pool> pool(new Pool(scope->settings(), label));
-  pool->set_depth(depth->int_value());
-
   // Save the generated item.
   Scope::ItemVector* collector = scope->GetItemCollector();
   if (!collector) {
     *err = Err(function, "Can't define a pool in this context.");
     return Value();
   }
   collector->push_back(pool.release());
 
   return Value();
 }
@@ skipping 329 matching lines @@
   }
 
   // Otherwise it's a no-block function.
   if (!VerifyNoBlockForFunctionCall(function, block, err))
     return Value();
   return found_function->second.no_block_runner(scope, function,
                                                 args.list_value(), err);
 }
 
 }  // namespace functions