Add public deps to GN

tools/gn/action_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/action_target_generator.h"
 
 #include "tools/gn/build_settings.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/parse_tree.h"
@@ skipping 11 matching lines @@
     : TargetGenerator(target, scope, function_call, err),
       output_type_(type) {
 }
 
 ActionTargetGenerator::~ActionTargetGenerator() {
 }
 
 void ActionTargetGenerator::DoRun() {
   target_->set_output_type(output_type_);
 
-  FillSources();
-  if (err_->has_error())
+  if (!FillSources())
     return;
   if (output_type_ == Target::ACTION_FOREACH && target_->sources().empty()) {
     // Foreach rules must always have some sources to have an effect.
     *err_ = Err(function_call_, "action_foreach target has no sources.",
         "If you don't specify any sources, there is nothing to run your\n"
         "script over.");
     return;
   }
 
-  FillInputs();
-  if (err_->has_error())
+  if (!FillInputs())
     return;
 
-  FillScript();
-  if (err_->has_error())
+  if (!FillScript())
     return;
 
-  FillScriptArgs();
-  if (err_->has_error())
+  if (!FillScriptArgs())
     return;
 
-  FillOutputs(output_type_ == Target::ACTION_FOREACH);
-  if (err_->has_error())
+  if (!FillOutputs(output_type_ == Target::ACTION_FOREACH))
     return;
 
-  FillDepfile();
-  if (err_->has_error())
+  if (!FillDepfile())
     return;
 
-  CheckOutputs();
-  if (err_->has_error())
+  if (!CheckOutputs())
     return;
 
   // Action outputs don't depend on the current toolchain so we can skip adding
   // that dependency.
 }
 
-void ActionTargetGenerator::FillScript() {
+bool ActionTargetGenerator::FillScript() {
   // If this gets called, the target type requires a script, so error out
   // if it doesn't have one.
   const Value* value = scope_->GetValue(variables::kScript, true);
   if (!value) {
     *err_ = Err(function_call_, "This target type requires a \"script\".");
-    return;
+    return true;

[jamesr, 2014/09/16 20:09:24]

wait, what does 'return true' mean? here we are returning true and populating an
error

[brettw, 2014/09/16 21:01:33]

Mistake

   }
   if (!value->VerifyTypeIs(Value::STRING, err_))
-    return;
+    return false;
 
   SourceFile script_file =
       scope_->GetSourceDir().ResolveRelativeFile(value->string_value());
   if (script_file.value().empty()) {
     *err_ = Err(*value, "script name is empty");
-    return;
+    return false;

[jamesr, 2014/09/16 20:09:24]

but here we are returning *false* and populating an error

   }
   target_->action_values().set_script(script_file);
+  return true;
 }
 
-void ActionTargetGenerator::FillScriptArgs() {
+bool ActionTargetGenerator::FillScriptArgs() {
   const Value* value = scope_->GetValue(variables::kArgs, true);
   if (!value)
-    return;
-
-  if (!target_->action_values().args().Parse(*value, err_))
-    return;
+    return true;
+  return target_->action_values().args().Parse(*value, err_);
 }
 
-void ActionTargetGenerator::FillDepfile() {
+bool ActionTargetGenerator::FillDepfile() {
   const Value* value = scope_->GetValue(variables::kDepfile, true);
   if (!value)
-    return;
+    return true;
 
   SubstitutionPattern depfile;
   if (!depfile.Parse(*value, err_))
-    return;
+    return false;
   if (!EnsureSubstitutionIsInOutputDir(depfile, *value))
-    return;
+    return false;
 
   target_->action_values().set_depfile(depfile);
+  return true;
 }
 
-void ActionTargetGenerator::CheckOutputs() {
+bool ActionTargetGenerator::CheckOutputs() {
   const SubstitutionList& outputs = target_->action_values().outputs();
   if (outputs.list().empty()) {
     *err_ = Err(function_call_, "Action has no outputs.",
         "If you have no outputs, the build system can not tell when your\n"
         "script needs to be run.");
-    return;
+    return false;
   }
 
   if (output_type_ == Target::ACTION) {
     if (!outputs.required_types().empty()) {
       *err_ = Err(function_call_, "Action has patterns in the output.",
           "An action target should have the outputs completely specified. If\n"
           "you want to provide a mapping from source to output, use an\n"
           "\"action_foreach\" target.");
-      return;
+      return false;
     }
   } else if (output_type_ == Target::ACTION_FOREACH) {
     // A foreach target should always have a pattern in the outputs.
     if (outputs.required_types().empty()) {
       *err_ = Err(function_call_,
           "action_foreach should have a pattern in the output.",
           "An action_foreach target should have a source expansion pattern in\n"
           "it to map source file to unique output file name. Otherwise, the\n"
           "build system can't determine when your script needs to be run.");
-      return;
+      return false;
     }
   }
+  return true;
 }