Support explicit pools in actions

tools/gn/builder.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/builder.h"
 
 #include <stddef.h>
 #include <utility>
 
+#include "tools/gn/action_values.h"
 #include "tools/gn/config.h"
 #include "tools/gn/deps_iterator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/loader.h"
 #include "tools/gn/pool.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/target.h"
 #include "tools/gn/trace.h"
 
@@ skipping 412 matching lines @@
   DCHECK(record->can_resolve() && !record->resolved());
 
   if (record->type() == BuilderRecord::ITEM_TARGET) {
     Target* target = record->item()->AsTarget();
     if (!ResolveDeps(&target->public_deps(), err) ||
         !ResolveDeps(&target->private_deps(), err) ||
         !ResolveDeps(&target->data_deps(), err) ||
         !ResolveConfigs(&target->configs(), err) ||
         !ResolveConfigs(&target->all_dependent_configs(), err) ||
         !ResolveConfigs(&target->public_configs(), err) ||
+        !ResolveActionValues(&target->action_values(), err) ||
         !ResolveToolchain(target, err))
       return false;
   } else if (record->type() == BuilderRecord::ITEM_CONFIG) {
     Config* config = record->item()->AsConfig();
     if (!ResolveConfigs(&config->configs(), err))
       return false;
   } else if (record->type() == BuilderRecord::ITEM_TOOLCHAIN) {
     Toolchain* toolchain = record->item()->AsToolchain();
     if (!ResolveDeps(&toolchain->deps(), err))
       return false;
@@ skipping 60 matching lines @@
         target->settings()->toolchain_label().GetUserVisibleName(false));
     return false;
   }
 
   if (!target->SetToolchain(record->item()->AsToolchain(), err))
     return false;
 
   return true;
 }
 
+bool Builder::ResolveActionValues(ActionValues* action_values, Err* err) {
+  if (action_values->pool().label.is_null())
+    return true;
+
+  BuilderRecord* record = GetResolvedRecordOfType(
+      action_values->pool().label, action_values->pool().origin,
+      BuilderRecord::ITEM_POOL, err);
+  if (!record)
+    return false;
+  action_values->set_pool(LabelPtrPair<Pool>(record->item()->AsPool()));
+
+  return true;
+}
+
 bool Builder::ResolvePools(Toolchain* toolchain, Err* err) {
   for (int i = Toolchain::TYPE_NONE + 1; i < Toolchain::TYPE_NUMTYPES; i++) {
     Toolchain::ToolType tool_type = static_cast<Toolchain::ToolType>(i);
     Tool* tool = toolchain->GetTool(tool_type);
     if (!tool || tool->pool().label.is_null())
       continue;
 
     BuilderRecord* record =
         GetResolvedRecordOfType(tool->pool().label, toolchain->defined_from(),
                                 BuilderRecord::ITEM_POOL, err);
@@ skipping 19 matching lines @@
   std::string ret;
   for (size_t i = 0; i < cycle.size(); i++) {
     ret += "  " + cycle[i]->label().GetUserVisibleName(false);
     if (i != cycle.size() - 1)
       ret += " ->";
     ret += "\n";
   }
 
   return ret;
 }