Make the gn copy() tool honor dependencies.

tools/gn/ninja_copy_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_copy_target_writer.h"
 
 #include "base/strings/string_util.h"
 #include "tools/gn/ninja_utils.h"
 #include "tools/gn/output_file.h"
 #include "tools/gn/scheduler.h"
@@ skipping 53 matching lines @@
   const SubstitutionList& output_subst_list =
       target_->action_values().outputs();
   CHECK_EQ(1u, output_subst_list.list().size())
       << "Should have one entry exactly.";
   const SubstitutionPattern& output_subst = output_subst_list.list()[0];
 
   std::string tool_name =
       GetNinjaRulePrefixForToolchain(settings_) +
       Toolchain::ToolTypeToName(Toolchain::TYPE_COPY);
 
+  OutputFile input_dep =
+      WriteInputDepsStampAndGetDep(std::vector<const Target*>());

[Dirk Pranke, 2014/10/30 02:22:19]

I just stole this from ninja_binary_target_writer; it's not clear to me if using
a stamp file for this is the right thing to do, though (vs. just writing out the
dependencies directly).

Also, it's not clear to me if this'll cause other dependencies to get written?
(I didn't write any tests for this yet or look at any existing tests).

+
   // Note that we don't write implicit deps for copy steps. "copy" only
   // depends on the output files themselves, rather than having includes
   // (the possibility of generated #includes is the main reason for implicit
   // dependencies).
   //
   // It would seem that specifying implicit dependencies on the deps of the
   // copy command would still be harmeless. But Chrome implements copy tools
   // as hard links (much faster) which don't change the timestamp. If the
   // ninja rule looks like this:
   //   output: copy input | foo.stamp
   // The copy will not make a new timestamp on the output file, but the
   // foo.stamp file generated from a previous step will have a new timestamp.
   // The copy rule will therefore look out-of-date to Ninja and the rule will
   // get rebuilt.
   //
   // If this copy is copying a generated file, not listing the implicit
   // dependency will be fine as long as the input to the copy is properly
   // listed as the output from the step that generated it.
   //
   // Moreover, doing this assumes that the copy step is always a simple
   // locally run command, so there is no need for a toolchain dependency.

[Dirk Pranke, 2014/10/30 02:22:19]

The comment above doesn't talk about order-only dependencies. Perhaps it should?

   for (size_t i = 0; i < target_->sources().size(); i++) {
     const SourceFile& input_file = target_->sources()[i];
 
     OutputFile output_file =
         SubstitutionWriter::ApplyPatternToSourceAsOutputFile(
             target_->settings(), output_subst, input_file);
     output_files->push_back(output_file);
 
     out_ << "build ";
     path_output_.WriteFile(out_, output_file);
     out_ << ": " << tool_name << " ";
     path_output_.WriteFile(out_, input_file);
+    if (!input_dep.value().empty()) {
+      out_ << " || ";
+      path_output_.WriteFile(out_, input_dep);
+    }
     out_ << std::endl;
   }
 }