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 200 matching lines @@
 
 bool Builder::TargetDefined(BuilderRecord* record, Err* err) {
   Target* target = record->item()->AsTarget();
 
   if (!AddDeps(record, target->public_deps(), err) ||
       !AddDeps(record, target->private_deps(), err) ||
       !AddDeps(record, target->data_deps(), err) ||
       !AddDeps(record, target->configs().vector(), err) ||
       !AddDeps(record, target->all_dependent_configs(), err) ||
       !AddDeps(record, target->public_configs(), err) ||
+      !AddActionValuesDep(record, target->action_values(), err) ||
       !AddToolchainDep(record, target, err))
     return false;
 
   // All targets in the default toolchain get generated by default. We also
   // check if this target was previously marked as "required" and force setting
   // the bit again so the target's dependencies (which we now know) get the
   // required bit pushed to them.
   if (record->should_generate() || target->settings()->is_default())
     RecursiveSetShouldGenerate(record, true);
 
@@ skipping 142 matching lines @@
   for (const auto& target : targets) {
     BuilderRecord* dep_record = GetOrCreateRecordOfType(
         target.label, target.origin, BuilderRecord::ITEM_TARGET, err);
     if (!dep_record)
       return false;
     record->AddDep(dep_record);
   }
   return true;
 }
 
+bool Builder::AddActionValuesDep(BuilderRecord* record,
+                                 const ActionValues& action_values,
+                                 Err* err) {
+  if (action_values.pool().label.is_null())
+    return true;
+
+  BuilderRecord* pool_record = GetResolvedRecordOfType(
+      action_values.pool().label, action_values.pool().origin,
+      BuilderRecord::ITEM_POOL, err);
+  if (!pool_record)
+    return false;
+  record->AddDep(pool_record);
+
+  return true;
+}
+
 bool Builder::AddToolchainDep(BuilderRecord* record,
                               const Target* target,
                               Err* err) {
   BuilderRecord* toolchain_record = GetOrCreateRecordOfType(
       target->settings()->toolchain_label(), target->defined_from(),
       BuilderRecord::ITEM_TOOLCHAIN, err);
   if (!toolchain_record)
     return false;
   record->AddDep(toolchain_record);
 
@@ skipping 30 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;
 }