Add support for user defined "pool" to GN.

tools/gn/ninja_toolchain_writer.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/ninja_toolchain_writer.h"
 
 #include <fstream>
 
 #include "base/files/file_util.h"
 #include "base/strings/stringize_macros.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/ninja_utils.h"
+#include "tools/gn/pool.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/substitution_writer.h"
 #include "tools/gn/target.h"
 #include "tools/gn/toolchain.h"
 #include "tools/gn/trace.h"
 
 namespace {
 
 const char kIndent[] = "  ";
 
@@ skipping 39 matching lines @@
     return false;
 
   NinjaToolchainWriter gen(settings, toolchain, targets, file);
   gen.Run();
   return true;
 }
 
 void NinjaToolchainWriter::WriteRules() {
   std::string rule_prefix = GetNinjaRulePrefixForToolchain(settings_);
 
+  UniqueVector<const Pool*> pools;
+  for (int i = Toolchain::TYPE_NONE + 1; i < Toolchain::TYPE_NUMTYPES; i++) {
+    Toolchain::ToolType tool_type = static_cast<Toolchain::ToolType>(i);
+    const Tool* tool = toolchain_->GetTool(tool_type);
+    if (tool && tool->pool_label_pair().ptr)
+      pools.push_back(tool->pool_label_pair().ptr);
+  }
+
+  if (!pools.empty()) {
+    for (const Pool* pool : pools) {
+      out_ << "pool " << rule_prefix << pool->label().name() << std::endl;

[brettw, 2016/05/24 22:03:31]

How the naming works here is a bit suspicious.

In the build files, a pool is identified by a label, but then only the past part
of that label is used for the actual pool name, so it must be globally unique.
Nothing else works this way. I think we should generate a name we give to Ninja
for the pool that's based on the full label name. Probably this name should also
include the toolchain of the pool (see my other comment in the documentation).

[sdefresne, 2016/05/26 15:38:37]

Done.

+      out_ << kIndent << "depth = " << pool->depth() << std::endl;
+    }
+    out_ << std::endl;
+  }
+
   for (int i = Toolchain::TYPE_NONE + 1; i < Toolchain::TYPE_NUMTYPES; i++) {
     Toolchain::ToolType tool_type = static_cast<Toolchain::ToolType>(i);
     const Tool* tool = toolchain_->GetTool(tool_type);
     if (tool)
       WriteToolRule(tool_type, tool, rule_prefix);
   }
   out_ << std::endl;
 }
 
 void NinjaToolchainWriter::WriteToolRule(const Toolchain::ToolType type,
@@ skipping 27 matching lines @@
   // The link pool applies to linker tools. Don't count TYPE_ALINK since
   // static libraries are not generally intensive to write.
   if (type == Toolchain::TYPE_SOLINK ||
       type == Toolchain::TYPE_SOLINK_MODULE ||
       type == Toolchain::TYPE_LINK) {
     out_ << kIndent << "pool = link_pool\n";
   }
 
   if (tool->restat())
     out_ << kIndent << "restat = 1" << std::endl;
+
+  if (tool->pool_label_pair().ptr) {
+    out_ << kIndent << "pool = "
+         << rule_prefix << tool->pool_label_pair().label.name() << std::endl;
+  }
 }
 
 void NinjaToolchainWriter::WriteRulePattern(const char* name,
                                             const SubstitutionPattern& pattern,
                                             const EscapeOptions& options) {
   if (pattern.empty())
     return;
   out_ << kIndent << name << " = ";
   SubstitutionWriter::WriteWithNinjaVariables(pattern, options, out_);
   out_ << std::endl;
 }
 
 void NinjaToolchainWriter::WriteSubninjas() {
   // Write subninja commands for each generated target.
   for (const auto& target : targets_) {
     OutputFile ninja_file(target->settings()->build_settings(),
                           GetNinjaFileForTarget(target));
     out_ << "subninja ";
     path_output_.WriteFile(out_, ninja_file);
     out_ << std::endl;
   }
   out_ << std::endl;
 }