GN: don't write separate files for non-binary targets

tools/gn/command_gen.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 "base/atomicops.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/timer/elapsed_timer.h"
@@ skipping 28 matching lines @@
 const char kSwitchIdeValueXcode[] = "xcode";
 const char kSwitchIdeValueJson[] = "json";
 const char kSwitchNinjaExtraArgs[] = "ninja-extra-args";
 const char kSwitchRootTarget[] = "root-target";
 const char kSwitchSln[] = "sln";
 const char kSwitchWorkspace[] = "workspace";
 const char kSwitchJsonFileName[] = "json-file-name";
 const char kSwitchJsonIdeScript[] = "json-ide-script";
 const char kSwitchJsonIdeScriptArgs[] = "json-ide-script-args";
 
+// Collects Ninja rules for each toolchain. The lock protectes the rules.
+struct TargetWriteInfo {
+  base::Lock lock;
+  NinjaWriter::PerToolchainRules rules;
+};
+
 // Called on worker thread to write the ninja file.
-void BackgroundDoWrite(const Target* target) {
-  NinjaTargetWriter::RunAndWriteFile(target);
+void BackgroundDoWrite(TargetWriteInfo* write_info, const Target* target) {
+  std::string rule = NinjaTargetWriter::RunAndWriteFile(target);
+  DCHECK(!rule.empty());
+
+  {
+    base::AutoLock lock(write_info->lock);
+    write_info->rules[target->toolchain()].emplace_back(
+        target, std::move(rule));
+  }
+
   g_scheduler->DecrementWorkCount();
 }
 
 // Called on the main thread.
-void ItemResolvedCallback(base::subtle::Atomic32* write_counter,
-                          scoped_refptr<Builder> builder,
+void ItemResolvedCallback(TargetWriteInfo* write_info,
                           const BuilderRecord* record) {
-  base::subtle::NoBarrier_AtomicIncrement(write_counter, 1);
-
   const Item* item = record->item();
   const Target* target = item->AsTarget();
   if (target) {
     g_scheduler->IncrementWorkCount();
-    g_scheduler->ScheduleWork(base::Bind(&BackgroundDoWrite, target));
+    g_scheduler->ScheduleWork(base::Bind(&BackgroundDoWrite,
+                                         write_info, target));
   }
 }
 
 // Returns a pointer to the target with the given file as an output, or null
 // if no targets generate the file. This is brute force since this is an
 // error condition and performance shouldn't matter.
-const Target* FindTargetThatGeneratesFile(const Builder* builder,
+const Target* FindTargetThatGeneratesFile(const Builder& builder,
                                           const SourceFile& file) {
-  std::vector<const Target*> targets = builder->GetAllResolvedTargets();
+  std::vector<const Target*> targets = builder.GetAllResolvedTargets();
   if (targets.empty())
     return nullptr;
 
   OutputFile output_file(targets[0]->settings()->build_settings(), file);
   for (const Target* target : targets) {
     for (const auto& cur_output : target->computed_outputs()) {
       if (cur_output == output_file)
         return target;
     }
   }
   return nullptr;
 }
 
 // Prints an error that the given file was present as a source or input in
 // the given target(s) but was not generated by any of its dependencies.
-void PrintInvalidGeneratedInput(const Builder* builder,
+void PrintInvalidGeneratedInput(const Builder& builder,
                                 const SourceFile& file,
                                 const std::vector<const Target*>& targets) {
   std::string err;
 
   // Only show the toolchain labels (which can be confusing) if something
   // isn't the default.
   bool show_toolchains = false;
   const Label& default_toolchain =
       targets[0]->settings()->default_toolchain_label();
   for (const Target* target : targets) {
@@ skipping 59 matching lines @@
 
   if (errors_found > 1) {
     OutputString(base::StringPrintf("\n%d generated input errors found.\n",
                                     errors_found), DECORATION_YELLOW);
   }
   return false;
 }
 
 bool RunIdeWriter(const std::string& ide,
                   const BuildSettings* build_settings,
-                  Builder* builder,
+                  const Builder& builder,
                   Err* err) {
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
   bool quiet = command_line->HasSwitch(switches::kQuiet);
   base::ElapsedTimer timer;
 
   if (ide == kSwitchIdeValueEclipse) {
     bool res = EclipseWriter::RunAndWriteFile(build_settings, builder, err);
     if (res && !quiet) {
       OutputString("Generating Eclipse settings took " +
@@ skipping 185 matching lines @@
   // Deliberately leaked to avoid expensive process teardown.
   Setup* setup = new Setup();
   if (!setup->DoSetup(args[0], true))
     return 1;
 
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(kSwitchCheck))
     setup->set_check_public_headers(true);
 
-  // Cause the load to also generate the ninja files for each target. We wrap
-  // the writing to maintain a counter.
-  base::subtle::Atomic32 write_counter = 0;
-  setup->builder()->set_resolved_callback(
-      base::Bind(&ItemResolvedCallback, &write_counter,
-                 scoped_refptr<Builder>(setup->builder())));
+  // Cause the load to also generate the ninja files for each target.
+  TargetWriteInfo write_info;
+  setup->builder().set_resolved_callback(
+      base::Bind(&ItemResolvedCallback, &write_info));
 
   // Do the actual load. This will also write out the target ninja files.
   if (!setup->Run())
     return 1;
 
+  // Sort the targets in each toolchain according to their label. This makes
+  // the ninja files have deterministic content.
+  for (auto& cur_toolchain : write_info.rules) {
+    std::sort(cur_toolchain.second.begin(), cur_toolchain.second.end(),
+              [](const NinjaWriter::TargetRulePair& a,
+                 const NinjaWriter::TargetRulePair& b) {
+                return a.first->label() < b.first->label();
+              });
+  }
+
   Err err;
   // Write the root ninja files.
   if (!NinjaWriter::RunAndWriteFiles(&setup->build_settings(),
                                      setup->builder(),
+                                     write_info.rules,
                                      &err)) {
     err.PrintToStdout();
     return 1;
   }
 
-  if (!WriteRuntimeDepsFilesIfNecessary(*setup->builder(), &err)) {
+  if (!WriteRuntimeDepsFilesIfNecessary(setup->builder(), &err)) {
     err.PrintToStdout();
     return 1;
   }
 
   if (!CheckForInvalidGeneratedInputs(setup))
     return 1;
 
   if (command_line->HasSwitch(kSwitchIde) &&
       !RunIdeWriter(command_line->GetSwitchValueASCII(kSwitchIde),
                     &setup->build_settings(), setup->builder(), &err)) {
     err.PrintToStdout();
     return 1;
   }
 
   base::TimeDelta elapsed_time = timer.Elapsed();
 
   if (!command_line->HasSwitch(switches::kQuiet)) {
     OutputString("Done. ", DECORATION_GREEN);
 
-    std::string stats = "Wrote " +
-        base::IntToString(static_cast<int>(write_counter)) +
+    size_t targets_collected = 0;
+    for (const auto& rules : write_info.rules)
+      targets_collected += rules.second.size();
+
+    std::string stats = "Made " + base::SizeTToString(targets_collected) +
         " targets from " +
         base::IntToString(
             setup->scheduler().input_file_manager()->GetInputFileCount()) +
         " files in " +
         base::Int64ToString(elapsed_time.InMilliseconds()) + "ms\n";
     OutputString(stats);
   }
 
   return 0;
 }
 
 }  // namespace commands