GN: toolchain threading cleanup

tools/gn/ninja_binary_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_binary_target_writer.h"
 
 #include <set>
 
 #include "base/strings/string_util.h"
 #include "tools/gn/config_values_extractors.h"
@@ skipping 68 matching lines @@
     case Target::EXECUTABLE:
       return Toolchain::TYPE_LINK;
     default:
       return Toolchain::TYPE_NONE;
   }
 }
 
 }  // namespace
 
 NinjaBinaryTargetWriter::NinjaBinaryTargetWriter(const Target* target,
+                                                 const Toolchain* toolchain,
                                                  std::ostream& out)
-    : NinjaTargetWriter(target, out),
+    : NinjaTargetWriter(target, toolchain, out),
       tool_type_(GetToolTypeForTarget(target)){
 }
 
 NinjaBinaryTargetWriter::~NinjaBinaryTargetWriter() {
 }
 
 void NinjaBinaryTargetWriter::Run() {
   WriteCompilerVars();
 
   std::vector<OutputFile> obj_files;
@@ skipping 37 matching lines @@
 #undef WRITE_FLAGS
 
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteSources(
     std::vector<OutputFile>* object_files) {
   const Target::FileList& sources = target_->sources();
   object_files->reserve(sources.size());
 
-  const Toolchain* toolchain = GetToolchain();
   std::string implicit_deps = GetSourcesImplicitDeps();
 
   for (size_t i = 0; i < sources.size(); i++) {
     const SourceFile& input_file = sources[i];
 
     SourceFileType input_file_type = GetSourceFileType(input_file,
                                                        settings_->target_os());
     if (input_file_type == SOURCE_UNKNOWN)
       continue;  // Skip unknown file types.
     std::string command =
-        helper_.GetRuleForSourceType(settings_, toolchain, input_file_type);
+        helper_.GetRuleForSourceType(settings_, input_file_type);
     if (command.empty())
       continue;  // Skip files not needing compilation.
 
     OutputFile output_file = helper_.GetOutputFileForSource(
         target_, input_file, input_file_type);
     object_files->push_back(output_file);
 
     out_ << "build ";
     path_output_.WriteFile(out_, output_file);
     out_ << ": " << command << " ";
@@ skipping 88 matching lines @@
 }
 
 void NinjaBinaryTargetWriter::WriteLinkerFlags() {
   out_ << "ldflags =";
 
   // First the ldflags from the target and its config.
   EscapeOptions flag_options = GetFlagOptions();
   RecursiveTargetConfigStringsToStream(target_, &ConfigValues::ldflags,
                                        flag_options, out_);
 
-  const Toolchain* toolchain = GetToolchain();
-  const Toolchain::Tool& tool = toolchain->GetTool(tool_type_);
+  const Toolchain::Tool& tool = toolchain_->GetTool(tool_type_);
 
   // Followed by library search paths that have been recursively pushed
   // through the dependency tree.
   const OrderedSet<SourceDir> all_lib_dirs = target_->all_lib_dirs();
   if (!all_lib_dirs.empty()) {
     // Since we're passing these on the command line to the linker and not
     // to Ninja, we need to do shell escaping.
     PathOutput lib_path_output(path_output_.current_dir(), ESCAPE_NINJA_SHELL,
                                true);
     for (size_t i = 0; i < all_lib_dirs.size(); i++) {
@@ skipping 19 matching lines @@
     const OutputFile& external_output_file,
     const OutputFile& internal_output_file,
     const std::vector<OutputFile>& object_files) {
   out_ << "build ";
   path_output_.WriteFile(out_, internal_output_file);
   if (external_output_file != internal_output_file) {
     out_ << " ";
     path_output_.WriteFile(out_, external_output_file);
   }
   out_ << ": "
-       << helper_.GetRulePrefix(GetToolchain())
+       << helper_.GetRulePrefix(target_->settings())
        << Toolchain::ToolTypeToName(tool_type_);
 
   std::set<OutputFile> extra_object_files;
   std::vector<const Target*> linkable_deps;
   std::vector<const Target*> non_linkable_deps;
   GetDeps(&extra_object_files, &linkable_deps, &non_linkable_deps);
 
   // Object files.
   for (size_t i = 0; i < object_files.size(); i++) {
     out_ << " ";
@@ skipping 19 matching lines @@
 
 void NinjaBinaryTargetWriter::WriteSourceSetStamp(
     const std::vector<OutputFile>& object_files) {
   // The stamp rule for source sets is generally not used, since targets that
   // depend on this will reference the object files directly. However, writing
   // this rule allows the user to type the name of the target and get a build
   // which can be convenient for development.
   out_ << "build ";
   path_output_.WriteFile(out_, helper_.GetTargetOutputFile(target_));
   out_ << ": "
-       << helper_.GetRulePrefix(target_->settings()->toolchain())
+       << helper_.GetRulePrefix(target_->settings())
        << "stamp";
 
   std::set<OutputFile> extra_object_files;
   std::vector<const Target*> linkable_deps;
   std::vector<const Target*> non_linkable_deps;
   GetDeps(&extra_object_files, &linkable_deps, &non_linkable_deps);
 
   // The classifier should never put extra object files in a source set:
   // any source sets that we depend on should appear in our non-linkable
   // deps instead.
@@ skipping 92 matching lines @@
     }
 
     // Data files.
     const std::vector<SourceFile>& data = target_->data();
     for (size_t i = 0; i < data.size(); i++) {
       out_ << " ";
       path_output_.WriteFile(out_, data[i]);
     }
   }
 }