Add support for data deps.

tools/gn/target_generator.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/target_generator.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/config.h"
 #include "tools/gn/config_values_generator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/item_node.h"
 #include "tools/gn/ninja_target_writer.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/target_manager.h"
 #include "tools/gn/token.h"
 #include "tools/gn/value.h"
 #include "tools/gn/value_extractors.h"
+#include "tools/gn/variables.h"
 
 namespace {
 
 bool TypeHasConfigs(Target::OutputType type) {
   return type == Target::EXECUTABLE ||
          type == Target::SHARED_LIBRARY ||
          type == Target::STATIC_LIBRARY ||
          type == Target::LOADABLE_MODULE;
 }
 
@@ skipping 56 matching lines @@
     FillSources();
   if (TypeHasData(output_type))
     FillData();
   if (output_type == Target::CUSTOM) {
     FillScript();
     FillScriptArgs();
   }
   if (TypeHasOutputs(output_type))
     FillOutputs();
   FillDependencies();  // All types have dependencies.
+  FillDataDependencies();  // All types have dependencies.
 
   if (TypeHasConfigValues(output_type)) {
     ConfigValuesGenerator gen(&target_->config_values(), scope_,
                               function_token_, input_directory_, err_);
     gen.Run();
     if (err_->has_error())
       return;
   }
 
   if (TypeHasDestDir(output_type))
@@ skipping 90 matching lines @@
     dest_configs[i] = Config::GetConfig(
         scope_->settings(),
         value->list_value()[i].origin()->GetRange(),
         labels[i], target_, err_);
     if (err_->has_error())
       return;
   }
   (target_->*setter)(&dest_configs);
 }
 
+void TargetGenerator::FillGenericDeps(
+    const char* var_name,
+    void (Target::*setter)(std::vector<const Target*>*)) {
+  const Value* value = scope_->GetValue(var_name, true);
+  if (!value)
+    return;
+
+  std::vector<Label> labels;
+  if (!ExtractListOfLabels(*value, input_directory_,
+                           ToolchainLabelForScope(scope_), &labels, err_))
+    return;
+
+  std::vector<const Target*> dest_deps;
+  dest_deps.resize(labels.size());
+  for (size_t i = 0; i < labels.size(); i++) {
+    dest_deps[i] = GetBuildSettings()->target_manager().GetTarget(
+        labels[i], value->list_value()[i].origin()->GetRange(), target_, err_);
+    if (err_->has_error())
+      return;
+  }
+
+  (target_->*setter)(&dest_deps);
+}
+
 void TargetGenerator::FillConfigs() {
-  FillGenericConfigs("configs", &Target::swap_in_configs);
+  FillGenericConfigs(variables::kConfigs, &Target::swap_in_configs);
 }
 
 void TargetGenerator::FillAllDependentConfigs() {
-  FillGenericConfigs("all_dependent_configs",
+  FillGenericConfigs(variables::kAllDependentConfigs,
                      &Target::swap_in_all_dependent_configs);
 }
 
 void TargetGenerator::FillDirectDependentConfigs() {
-  FillGenericConfigs("direct_dependent_configs",
+  FillGenericConfigs(variables::kDirectDependentConfigs,
                      &Target::swap_in_direct_dependent_configs);
 }
 
 void TargetGenerator::FillSources() {
-  const Value* value = scope_->GetValue("sources", true);
+  const Value* value = scope_->GetValue(variables::kSources, true);
   if (!value)
     return;
 
   Target::FileList dest_sources;
   if (!ExtractListOfRelativeFiles(*value, input_directory_, &dest_sources,
                                   err_))
     return;
   target_->swap_in_sources(&dest_sources);
 }
 
 void TargetGenerator::FillData() {
+  // TODO(brettW) hook this up to the constant when we have cleaned up
+  // how data files are used.
   const Value* value = scope_->GetValue("data", true);
   if (!value)
     return;
 
   Target::FileList dest_data;
   if (!ExtractListOfRelativeFiles(*value, input_directory_, &dest_data,
                                   err_))
     return;
   target_->swap_in_data(&dest_data);
 }
 
 void TargetGenerator::FillDependencies() {
-  const Value* value = scope_->GetValue("deps", true);
-  if (!value)
-    return;
+  FillGenericDeps(variables::kDeps, &Target::swap_in_deps);
+}
 
-  std::vector<Label> labels;
-  if (!ExtractListOfLabels(*value, input_directory_,
-                           ToolchainLabelForScope(scope_), &labels, err_))
-    return;
-
-  std::vector<const Target*> dest_deps;
-  dest_deps.resize(labels.size());
-  for (size_t i = 0; i < labels.size(); i++) {
-    dest_deps[i] = GetBuildSettings()->target_manager().GetTarget(
-        labels[i], value->list_value()[i].origin()->GetRange(), target_, err_);
-    if (err_->has_error())
-      return;
-  }
-
-  target_->swap_in_deps(&dest_deps);
+void TargetGenerator::FillDataDependencies() {
+  FillGenericDeps(variables::kDatadeps, &Target::swap_in_datadeps);
 }
 
 void TargetGenerator::FillDestDir() {
   // Destdir is required for all targets that use it.
   const Value* value = scope_->GetValue("destdir", true);
   if (!value) {
     *err_ = Err(function_token_, "This target type requires a \"destdir\".");
     return;
   }
   if (!value->VerifyTypeIs(Value::STRING, err_))
@@ skipping 48 matching lines @@
             GetBuildSettings()->build_dir(),
             outputs[i].value(), value->list_value()[i], err_))
       return;
   }
   target_->swap_in_outputs(&outputs);
 }
 
 const BuildSettings* TargetGenerator::GetBuildSettings() const {
   return scope_->settings()->build_settings();
 }