Add public deps to GN

tools/gn/ninja_action_target_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_action_target_writer.h"
 
 #include "base/strings/string_util.h"
+#include "tools/gn/deps_iterator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/string_utils.h"
 #include "tools/gn/substitution_writer.h"
 #include "tools/gn/target.h"
 
 NinjaActionTargetWriter::NinjaActionTargetWriter(const Target* target,
                                                  std::ostream& out)
     : NinjaTargetWriter(target, out),
       path_output_no_escaping_(
           target->settings()->build_settings()->build_dir(),
           ESCAPE_NONE) {
 }
 
 NinjaActionTargetWriter::~NinjaActionTargetWriter() {
 }
 
 void NinjaActionTargetWriter::Run() {
   std::string custom_rule_name = WriteRuleDefinition();
 
   // Collect our deps to pass as "extra hard dependencies" for input deps. This
   // will force all of the action's dependencies to be completed before the
   // action is run. Usually, if an action has a dependency, it will be
   // operating on the result of that previous step, so we need to be sure to
   // serialize these.
   std::vector<const Target*> extra_hard_deps;
-  for (size_t i = 0; i < target_->deps().size(); i++)
-    extra_hard_deps.push_back(target_->deps()[i].ptr);
+  for (DepsIterator iter(target_, DepsIterator::LINKED_ONLY);
+       !iter.done(); iter.Advance())
+    extra_hard_deps.push_back(iter.target());
 
   // For ACTIONs this is a bit inefficient since it creates an input dep
   // stamp file even though we're only going to use it once. It would save a
   // build step to skip this and write the order-only deps directly on the
   // build rule. This should probably be handled by WriteInputDepsStampAndGetDep
   // automatically if we supply a count of sources (so it can optimize based on
   // how many times things would be duplicated).
   OutputFile input_dep = WriteInputDepsStampAndGetDep(extra_hard_deps);
   out_ << std::endl;
 
@@ skipping 22 matching lines @@
     }
     out_ << std::endl;
     if (target_->action_values().has_depfile()) {
       out_ << "  depfile = ";
       WriteDepfile(SourceFile());
       out_ << std::endl;
     }
   }
   out_ << std::endl;
 
-  // Write the stamp, which also depends on all datadeps. These are needed at
+  // Write the stamp, which also depends on all data deps. These are needed at
   // runtime and should be compiled when the action is, but don't need to be
   // done before we run the action.
   std::vector<OutputFile> data_outs;
-  for (size_t i = 0; i < target_->datadeps().size(); i++)
-    data_outs.push_back(target_->datadeps()[i].ptr->dependency_output_file());
+  for (size_t i = 0; i < target_->data_deps().size(); i++)
+    data_outs.push_back(target_->data_deps()[i].ptr->dependency_output_file());
   WriteStampForTarget(output_files, data_outs);
 }
 
 std::string NinjaActionTargetWriter::WriteRuleDefinition() {
   // Make a unique name for this rule.
   //
   // Use a unique name for the response file when there are multiple build
   // steps so that they don't stomp on each other. When there are no sources,
   // there will be only one invocation so we can use a simple name.
   std::string target_label = target_->label().GetUserVisibleName(true);
@@ skipping 113 matching lines @@
     out_ << " ";
     path_output_.WriteFile(out_, (*output_files)[i]);
   }
 }
 
 void NinjaActionTargetWriter::WriteDepfile(const SourceFile& source) {
   path_output_.WriteFile(out_,
       SubstitutionWriter::ApplyPatternToSourceAsOutputFile(
           settings_, target_->action_values().depfile(), source));
 }