diff --git a/tools/gn/builder.h b/tools/gn/builder.h
index 0c2fe70..d8209bc 100644
--- a/tools/gn/builder.h
+++ b/tools/gn/builder.h
@@ -8,7 +8,6 @@
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
-#include "base/memory/ref_counted.h"
 #include "tools/gn/builder_record.h"
 #include "tools/gn/label.h"
 #include "tools/gn/label_ptr.h"
@@ -19,11 +18,14 @@
 class Loader;
 class ParseNode;
 
-class Builder : public base::RefCountedThreadSafe<Builder> {
+// The builder assembles the dependency tree. It is not threadsafe and runs on
+// the main thread only. See also BuilderRecord.
+class Builder {
  public:
   typedef base::Callback<void(const BuilderRecord*)> ResolvedCallback;
 
   explicit Builder(Loader* loader);
+  ~Builder();
 
   // The resolved callback is called whenever a target has been resolved. This
   // will be executed only on the main thread.
@@ -53,10 +55,6 @@
   bool CheckForBadItems(Err* err) const;
 
  private:
-  friend class base::RefCountedThreadSafe<Builder>;
-
-  virtual ~Builder();
-
   bool TargetDefined(BuilderRecord* record, Err* err);
   bool ConfigDefined(BuilderRecord* record, Err* err);
   bool ToolchainDefined(BuilderRecord* record, Err* err);
diff --git a/tools/gn/builder_unittest.cc b/tools/gn/builder_unittest.cc
index 96fad7d..616e76a 100644
--- a/tools/gn/builder_unittest.cc
+++ b/tools/gn/builder_unittest.cc
@@ -67,7 +67,7 @@
  public:
   BuilderTest()
       : loader_(new MockLoader),
-        builder_(new Builder(loader_.get())),
+        builder_(loader_.get()),
         settings_(&build_settings_, std::string()),
         scope_(&settings_) {
     build_settings_.SetBuildDir(SourceDir("//out/"));
@@ -78,13 +78,13 @@
   Toolchain* DefineToolchain() {
     Toolchain* tc = new Toolchain(&settings_, settings_.toolchain_label());
     TestWithScope::SetupToolchain(tc);
-    builder_->ItemDefined(std::unique_ptr<Item>(tc));
+    builder_.ItemDefined(std::unique_ptr<Item>(tc));
     return tc;
   }
 
  protected:
   scoped_refptr<MockLoader> loader_;
-  scoped_refptr<Builder> builder_;
+  Builder builder_;
   BuildSettings build_settings_;
   Settings settings_;
   Scope scope_;
@@ -107,7 +107,7 @@
   Target* a = new Target(&settings_, a_label);
   a->public_deps().push_back(LabelTargetPair(b_label));
   a->set_output_type(Target::EXECUTABLE);
-  builder_->ItemDefined(std::unique_ptr<Item>(a));
+  builder_.ItemDefined(std::unique_ptr<Item>(a));
 
   // Should have requested that B and the toolchain is loaded.
   EXPECT_TRUE(loader_->HasLoadedTwo(SourceFile("//tc/BUILD.gn"),
@@ -116,18 +116,18 @@
   // Define the toolchain.
   DefineToolchain();
   BuilderRecord* toolchain_record =
-      builder_->GetRecord(settings_.toolchain_label());
+      builder_.GetRecord(settings_.toolchain_label());
   ASSERT_TRUE(toolchain_record);
   EXPECT_EQ(BuilderRecord::ITEM_TOOLCHAIN, toolchain_record->type());
 
   // A should be unresolved with an item
-  BuilderRecord* a_record = builder_->GetRecord(a_label);
+  BuilderRecord* a_record = builder_.GetRecord(a_label);
   EXPECT_TRUE(a_record->item());
   EXPECT_FALSE(a_record->resolved());
   EXPECT_FALSE(a_record->can_resolve());
 
   // B should be unresolved, have no item, and no deps.
-  BuilderRecord* b_record = builder_->GetRecord(b_label);
+  BuilderRecord* b_record = builder_.GetRecord(b_label);
   EXPECT_FALSE(b_record->item());
   EXPECT_FALSE(b_record->resolved());
   EXPECT_FALSE(b_record->can_resolve());
@@ -152,7 +152,7 @@
   Target* c = new Target(&settings_, c_label);
   c->set_output_type(Target::STATIC_LIBRARY);
   c->visibility().SetPublic();
-  builder_->ItemDefined(std::unique_ptr<Item>(c));
+  builder_.ItemDefined(std::unique_ptr<Item>(c));
 
   // C only depends on the already-loaded toolchain so we shouldn't have
   // requested anything else.
@@ -163,14 +163,14 @@
   a->public_deps().push_back(LabelTargetPair(c_label));
   b->set_output_type(Target::SHARED_LIBRARY);
   b->visibility().SetPublic();
-  builder_->ItemDefined(std::unique_ptr<Item>(b));
+  builder_.ItemDefined(std::unique_ptr<Item>(b));
 
   // B depends only on the already-loaded C and toolchain so we shouldn't have
   // requested anything else.
   EXPECT_TRUE(loader_->HasLoadedNone());
 
   // All targets should now be resolved.
-  BuilderRecord* c_record = builder_->GetRecord(c_label);
+  BuilderRecord* c_record = builder_.GetRecord(c_label);
   EXPECT_TRUE(a_record->resolved());
   EXPECT_TRUE(b_record->resolved());
   EXPECT_TRUE(c_record->resolved());
@@ -194,7 +194,7 @@
   settings2.set_toolchain_label(toolchain_label2);
   Toolchain* tc2 = new Toolchain(&settings2, toolchain_label2);
   TestWithScope::SetupToolchain(tc2);
-  builder_->ItemDefined(std::unique_ptr<Item>(tc2));
+  builder_.ItemDefined(std::unique_ptr<Item>(tc2));
 
   // Construct a dependency chain: A -> B. A is in the default toolchain, B
   // is not.
@@ -207,20 +207,20 @@
   Target* b = new Target(&settings2, b_label);
   b->visibility().SetPublic();
   b->set_output_type(Target::EXECUTABLE);
-  builder_->ItemDefined(std::unique_ptr<Item>(b));
+  builder_.ItemDefined(std::unique_ptr<Item>(b));
 
   // B should not be marked generated by default.
-  BuilderRecord* b_record = builder_->GetRecord(b_label);
+  BuilderRecord* b_record = builder_.GetRecord(b_label);
   EXPECT_FALSE(b_record->should_generate());
 
   // Define A with a dependency on B.
   Target* a = new Target(&settings_, a_label);
   a->public_deps().push_back(LabelTargetPair(b_label));
   a->set_output_type(Target::EXECUTABLE);
-  builder_->ItemDefined(std::unique_ptr<Item>(a));
+  builder_.ItemDefined(std::unique_ptr<Item>(a));
 
   // A should have the generate bit set since it's in the default toolchain.
-  BuilderRecord* a_record = builder_->GetRecord(a_label);
+  BuilderRecord* a_record = builder_.GetRecord(a_label);
   EXPECT_TRUE(a_record->should_generate());
 
   // It should have gotten pushed to B.
@@ -242,7 +242,7 @@
   // The builder will take ownership of the pointers.
   Config* a = new Config(&settings_, a_label);
   a->configs().push_back(LabelConfigPair(b_label));
-  builder_->ItemDefined(std::unique_ptr<Item>(a));
+  builder_.ItemDefined(std::unique_ptr<Item>(a));
 
   // Should have requested that B is loaded.
   EXPECT_TRUE(loader_->HasLoadedOne(SourceFile("//b/BUILD.gn")));
diff --git a/tools/gn/command_check.cc b/tools/gn/command_check.cc
index 40931a6..467644b 100644
--- a/tools/gn/command_check.cc
+++ b/tools/gn/command_check.cc
@@ -184,7 +184,7 @@
     return 1;
 
   std::vector<const Target*> all_targets =
-      setup->builder()->GetAllResolvedTargets();
+      setup->builder().GetAllResolvedTargets();
 
   bool filtered_by_build_config = false;
   std::vector<const Target*> targets_to_check;
diff --git a/tools/gn/command_gen.cc b/tools/gn/command_gen.cc
index 06b99ca..7de9aed 100644
--- a/tools/gn/command_gen.cc
+++ b/tools/gn/command_gen.cc
@@ -46,32 +46,44 @@
 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;
 
@@ -87,7 +99,7 @@
 
 // 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;
@@ -167,7 +179,7 @@
 
 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();
@@ -373,27 +385,36 @@
   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;
   }
@@ -413,8 +434,11 @@
   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()) +
diff --git a/tools/gn/command_ls.cc b/tools/gn/command_ls.cc
index f53a727..4d14e0f 100644
--- a/tools/gn/command_ls.cc
+++ b/tools/gn/command_ls.cc
@@ -97,10 +97,10 @@
                    target_matches.begin(), target_matches.end());
   } else if (all_toolchains) {
     // List all resolved targets.
-    matches = setup->builder()->GetAllResolvedTargets();
+    matches = setup->builder().GetAllResolvedTargets();
   } else {
     // List all resolved targets in the default toolchain.
-    for (auto* target : setup->builder()->GetAllResolvedTargets()) {
+    for (auto* target : setup->builder().GetAllResolvedTargets()) {
       if (target->settings()->is_default())
         matches.push_back(target);
     }
diff --git a/tools/gn/command_refs.cc b/tools/gn/command_refs.cc
index 64969b9..184f901 100644
--- a/tools/gn/command_refs.cc
+++ b/tools/gn/command_refs.cc
@@ -33,7 +33,7 @@
 
 // Populates the reverse dependency map for the targets in the Setup.
 void FillDepMap(Setup* setup, DepMap* dep_map) {
-  for (auto* target : setup->builder()->GetAllResolvedTargets()) {
+  for (auto* target : setup->builder().GetAllResolvedTargets()) {
     for (const auto& dep_pair : target->GetDeps(Target::DEPS_ALL))
       dep_map->insert(std::make_pair(dep_pair.ptr, target));
   }
@@ -443,7 +443,7 @@
   // the output, while for normal targets you don't want to see the inputs,
   // only what refers to them.
   std::vector<const Target*> all_targets =
-      setup->builder()->GetAllResolvedTargets();
+      setup->builder().GetAllResolvedTargets();
   UniqueVector<const Target*> explicit_target_matches;
   for (const auto& file : file_matches) {
     GetTargetsContainingFile(setup, all_targets, file, all_toolchains,
diff --git a/tools/gn/commands.cc b/tools/gn/commands.cc
index 492b74f..bf89c95 100644
--- a/tools/gn/commands.cc
+++ b/tools/gn/commands.cc
@@ -56,7 +56,7 @@
 
   std::vector<LabelPattern> pattern_vector;
   pattern_vector.push_back(pattern);
-  FilterTargetsByPatterns(setup->builder()->GetAllResolvedTargets(),
+  FilterTargetsByPatterns(setup->builder().GetAllResolvedTargets(),
                           pattern_vector, matches);
   return true;
 }
@@ -102,7 +102,7 @@
     return true;
   }
 
-  const Item* item = setup->builder()->GetItem(label);
+  const Item* item = setup->builder().GetItem(label);
   if (item) {
     if (const Config* as_config = item->AsConfig())
       config_matches->push_back(as_config);
@@ -391,7 +391,7 @@
     return nullptr;
   }
 
-  const Item* item = setup->builder()->GetItem(label);
+  const Item* item = setup->builder().GetItem(label);
   if (!item) {
     Err(Location(), "Label not found.",
         label.GetUserVisibleName(false) + " not found.").PrintToStdout();
diff --git a/tools/gn/eclipse_writer.cc b/tools/gn/eclipse_writer.cc
index ee91f61..dbc6eb9 100644
--- a/tools/gn/eclipse_writer.cc
+++ b/tools/gn/eclipse_writer.cc
@@ -36,7 +36,7 @@
 }  // namespace
 
 EclipseWriter::EclipseWriter(const BuildSettings* build_settings,
-                             const Builder* builder,
+                             const Builder& builder,
                              std::ostream& out)
     : build_settings_(build_settings), builder_(builder), out_(out) {
   languages_.push_back("C++ Source File");
@@ -52,7 +52,7 @@
 // static
 bool EclipseWriter::RunAndWriteFile(
     const BuildSettings* build_settings,
-    const Builder* builder,
+    const Builder& builder,
     Err* err) {
   base::FilePath file = build_settings->GetFullPath(build_settings->build_dir())
                             .AppendASCII("eclipse-cdt-settings.xml");
@@ -77,7 +77,7 @@
 }
 
 void EclipseWriter::GetAllIncludeDirs() {
-  std::vector<const Target*> targets = builder_->GetAllResolvedTargets();
+  std::vector<const Target*> targets = builder_.GetAllResolvedTargets();
   for (const Target* target : targets) {
     if (!UsesDefaultToolchain(target))
       continue;
@@ -92,7 +92,7 @@
 }
 
 void EclipseWriter::GetAllDefines() {
-  std::vector<const Target*> targets = builder_->GetAllResolvedTargets();
+  std::vector<const Target*> targets = builder_.GetAllResolvedTargets();
   for (const Target* target : targets) {
     if (!UsesDefaultToolchain(target))
       continue;
@@ -116,7 +116,7 @@
 
 bool EclipseWriter::UsesDefaultToolchain(const Target* target) const {
   return target->toolchain()->label() ==
-         builder_->loader()->GetDefaultToolchain();
+         builder_.loader()->GetDefaultToolchain();
 }
 
 void EclipseWriter::WriteCDTSettings() {
diff --git a/tools/gn/eclipse_writer.h b/tools/gn/eclipse_writer.h
index 560b872..e15254f 100644
--- a/tools/gn/eclipse_writer.h
+++ b/tools/gn/eclipse_writer.h
@@ -21,12 +21,12 @@
 class EclipseWriter {
  public:
   static bool RunAndWriteFile(const BuildSettings* build_settings,
-                              const Builder* builder,
+                              const Builder& builder,
                               Err* err);
 
  private:
   EclipseWriter(const BuildSettings* build_settings,
-                const Builder* builder,
+                const Builder& builder,
                 std::ostream& out);
   ~EclipseWriter();
 
@@ -47,7 +47,7 @@
   void WriteCDTSettings();
 
   const BuildSettings* build_settings_;
-  const Builder* builder_;
+  const Builder& builder_;
 
   // The output stream for the settings file.
   std::ostream& out_;
diff --git a/tools/gn/json_project_writer.cc b/tools/gn/json_project_writer.cc
index 272a288..dc375a6 100644
--- a/tools/gn/json_project_writer.cc
+++ b/tools/gn/json_project_writer.cc
@@ -82,7 +82,7 @@
 }
 
 std::string RenderJSON(const BuildSettings* build_settings,
-                       const Builder* builder,
+                       const Builder& builder,
                        std::vector<const Target*>& all_targets) {
   Label default_toolchain_label;
 
@@ -167,7 +167,7 @@
 
 bool JSONProjectWriter::RunAndWriteFiles(
     const BuildSettings* build_settings,
-    const Builder* builder,
+    const Builder& builder,
     const std::string& file_name,
     const std::string& exec_script,
     const std::string& exec_script_extra_args,
@@ -182,7 +182,7 @@
 
   base::FilePath output_path = build_settings->GetFullPath(output_file);
 
-  std::vector<const Target*> all_targets = builder->GetAllResolvedTargets();
+  std::vector<const Target*> all_targets = builder.GetAllResolvedTargets();
   std::vector<const Target*> targets;
   if (!FilterTargets(build_settings, all_targets, &targets, dir_filter_string,
                      err)) {
diff --git a/tools/gn/json_project_writer.h b/tools/gn/json_project_writer.h
index e69dc3a..8c293bf 100644
--- a/tools/gn/json_project_writer.h
+++ b/tools/gn/json_project_writer.h
@@ -14,7 +14,7 @@
 class JSONProjectWriter {
  public:
   static bool RunAndWriteFiles(const BuildSettings* build_setting,
-                               const Builder* builder,
+                               const Builder& builder,
                                const std::string& file_name,
                                const std::string& exec_script,
                                const std::string& exec_script_extra_args,
diff --git a/tools/gn/ninja_build_writer.cc b/tools/gn/ninja_build_writer.cc
index 8ee90b0..a7f56f9 100644
--- a/tools/gn/ninja_build_writer.cc
+++ b/tools/gn/ninja_build_writer.cc
@@ -18,10 +18,12 @@
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "tools/gn/build_settings.h"
+#include "tools/gn/builder.h"
 #include "tools/gn/err.h"
 #include "tools/gn/escape.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/input_file_manager.h"
+#include "tools/gn/loader.h"
 #include "tools/gn/ninja_utils.h"
 #include "tools/gn/pool.h"
 #include "tools/gn/scheduler.h"
@@ -127,17 +129,15 @@
 
 NinjaBuildWriter::NinjaBuildWriter(
     const BuildSettings* build_settings,
-    const std::vector<const Settings*>& all_settings,
+    const std::map<const Settings*, const Toolchain*>& used_toolchains,
     const Toolchain* default_toolchain,
     const std::vector<const Target*>& default_toolchain_targets,
-    const std::vector<const Pool*>& all_pools,
     std::ostream& out,
     std::ostream& dep_out)
     : build_settings_(build_settings),
-      all_settings_(all_settings),
+      used_toolchains_(used_toolchains),
       default_toolchain_(default_toolchain),
       default_toolchain_targets_(default_toolchain_targets),
-      all_pools_(all_pools),
       out_(out),
       dep_out_(dep_out),
       path_output_(build_settings->build_dir(),
@@ -157,17 +157,42 @@
 // static
 bool NinjaBuildWriter::RunAndWriteFile(
     const BuildSettings* build_settings,
-    const std::vector<const Settings*>& all_settings,
-    const Toolchain* default_toolchain,
-    const std::vector<const Target*>& default_toolchain_targets,
-    const std::vector<const Pool*>& all_pools,
+    const Builder& builder,
     Err* err) {
   ScopedTrace trace(TraceItem::TRACE_FILE_WRITE, "build.ninja");
 
+  std::vector<const Target*> all_targets = builder.GetAllResolvedTargets();
+  std::map<const Settings*, const Toolchain*> used_toolchains;
+
+  // Find the default toolchain info.
+  Label default_toolchain_label = builder.loader()->GetDefaultToolchain();
+  const Settings* default_toolchain_settings =
+      builder.loader()->GetToolchainSettings(default_toolchain_label);
+  const Toolchain* default_toolchain =
+      builder.GetToolchain(default_toolchain_label);
+
+  // Most targets will be in the default toolchain. Add it at the beginning and
+  // skip adding it to the list every time in the loop.
+  used_toolchains[default_toolchain_settings] = default_toolchain;
+
+  std::vector<const Target*> default_toolchain_targets;
+  default_toolchain_targets.reserve(all_targets.size());
+  for (const Target* target : all_targets) {
+    if (target->settings() == default_toolchain_settings) {
+      default_toolchain_targets.push_back(target);
+      // The default toolchain will already have been added to the used
+      // settings array.
+    } else if (used_toolchains.find(target->settings()) ==
+               used_toolchains.end()) {
+      used_toolchains[target->settings()] =
+          builder.GetToolchain(target->settings()->toolchain_label());
+    }
+  }
+
   std::stringstream file;
   std::stringstream depfile;
-  NinjaBuildWriter gen(build_settings, all_settings, default_toolchain,
-                       default_toolchain_targets, all_pools, file, depfile);
+  NinjaBuildWriter gen(build_settings, used_toolchains, default_toolchain,
+                       default_toolchain_targets, file, depfile);
   if (!gen.Run(err))
     return false;
 
@@ -233,7 +258,18 @@
        << "  depth = " << default_toolchain_->concurrent_links() << std::endl
        << std::endl;
 
-  for (const Pool* pool : all_pools_) {
+  // Compute the pools referenced by all tools of all used toolchains.
+  std::set<const Pool*> used_pools;
+  for (const auto& pair : used_toolchains_) {
+    for (int j = Toolchain::TYPE_NONE + 1; j < Toolchain::TYPE_NUMTYPES; j++) {
+      Toolchain::ToolType tool_type = static_cast<Toolchain::ToolType>(j);
+      const Tool* tool = pair.second->GetTool(tool_type);
+      if (tool && tool->pool().ptr)
+        used_pools.insert(tool->pool().ptr);
+    }
+  }
+
+  for (const Pool* pool : used_pools) {
     std::string pool_name = pool->GetNinjaName(default_toolchain_->label());
     out_ << "pool " << pool_name << std::endl
          << "  depth = " << pool->depth() << std::endl
@@ -242,9 +278,9 @@
 }
 
 void NinjaBuildWriter::WriteSubninjas() {
-  for (auto* elem : all_settings_) {
+  for (const auto& pair : used_toolchains_) {
     out_ << "subninja ";
-    path_output_.WriteFile(out_, GetNinjaFileForToolchain(elem));
+    path_output_.WriteFile(out_, GetNinjaFileForToolchain(pair.first));
     out_ << std::endl;
   }
   out_ << std::endl;
diff --git a/tools/gn/ninja_build_writer.h b/tools/gn/ninja_build_writer.h
index 358ecc6..cf72852 100644
--- a/tools/gn/ninja_build_writer.h
+++ b/tools/gn/ninja_build_writer.h
@@ -6,12 +6,13 @@
 #define TOOLS_GN_NINJA_BUILD_WRITER_H_
 
 #include <iosfwd>
-#include <set>
+#include <map>
 #include <vector>
 
 #include "base/macros.h"
 #include "tools/gn/path_output.h"
 
+class Builder;
 class BuildSettings;
 class Err;
 class Pool;
@@ -24,38 +25,42 @@
 // build itself.
 class NinjaBuildWriter {
  public:
-  static bool RunAndWriteFile(
+  NinjaBuildWriter(
       const BuildSettings* settings,
-      const std::vector<const Settings*>& all_settings,
+      const std::map<const Settings*, const Toolchain*>& used_toolchains,
       const Toolchain* default_toolchain,
       const std::vector<const Target*>& default_toolchain_targets,
-      const std::vector<const Pool*>& all_pools,
-      Err* err);
-
-  NinjaBuildWriter(const BuildSettings* settings,
-                   const std::vector<const Settings*>& all_settings,
-                   const Toolchain* default_toolchain,
-                   const std::vector<const Target*>& default_toolchain_targets,
-                   const std::vector<const Pool*>& all_pools,
-                   std::ostream& out,
-                   std::ostream& dep_out);
+      std::ostream& out,
+      std::ostream& dep_out);
   ~NinjaBuildWriter();
 
+  // The design of this class is that this static factory function takes the
+  // Builder, extracts the relevant information, and passes it to the class
+  // constructor. The class itself doesn't depend on the Builder at all which
+  // makes testing much easier (tests integrating various functions along with
+  // the Builder get very complicated).
+  static bool RunAndWriteFile(
+      const BuildSettings* settings,
+      const Builder& builder,
+      Err* err);
+
   bool Run(Err* err);
 
  private:
   void WriteNinjaRules();
   void WriteAllPools();
   void WriteSubninjas();
-  bool WritePhonyAndAllRules(Err* err);
+  bool WritePhonyAndAllRules(
+      Err* err);
 
   void WritePhonyRule(const Target* target, const std::string& phony_name);
 
   const BuildSettings* build_settings_;
-  std::vector<const Settings*> all_settings_;
+
+  const std::map<const Settings*, const Toolchain*>& used_toolchains_;
   const Toolchain* default_toolchain_;
-  std::vector<const Target*> default_toolchain_targets_;
-  std::vector<const Pool*> all_pools_;
+  const std::vector<const Target*>& default_toolchain_targets_;
+
   std::ostream& out_;
   std::ostream& dep_out_;
   PathOutput path_output_;
diff --git a/tools/gn/ninja_build_writer_unittest.cc b/tools/gn/ninja_build_writer_unittest.cc
index 955eb1c..abb5475 100644
--- a/tools/gn/ninja_build_writer_unittest.cc
+++ b/tools/gn/ninja_build_writer_unittest.cc
@@ -32,47 +32,57 @@
   target_bar.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target_bar.OnResolved(&err));
 
-  Pool swiming_pool(setup.settings(),
-                    Label(SourceDir("//swiming/"), "pool",
-                          SourceDir("//other/"), "toolchain"));
-  swiming_pool.set_depth(42);
+  // Make a secondary toolchain that references a pool.
+  Label other_toolchain_label(SourceDir("//other/"), "toolchain");
+  Pool other_pool(setup.settings(),
+                    Label(SourceDir("//other/"), "pool",
+                          other_toolchain_label.dir(),
+                          other_toolchain_label.name()));
+  other_pool.set_depth(42);
+  Toolchain other_toolchain(setup.settings(), other_toolchain_label);
+  TestWithScope::SetupToolchain(&other_toolchain);
+  other_toolchain.GetTool(Toolchain::TYPE_LINK)->set_pool(
+      LabelPtrPair<Pool>(&other_pool));
+
+  // Settings to go with the other toolchain.
+  Settings other_settings(setup.build_settings(), "toolchain/");
+  other_settings.set_toolchain_label(other_toolchain_label);
+
+  std::map<const Settings*, const Toolchain*> used_toolchains;
+  used_toolchains[setup.settings()] = setup.toolchain();
+  used_toolchains[&other_settings] = &other_toolchain;
+
+  std::vector<const Target*> targets = { &target_foo, &target_bar };
 
   std::ostringstream ninja_out;
   std::ostringstream depfile_out;
-  std::vector<const Settings*> all_settings = {setup.settings()};
-  std::vector<const Target*> targets = {&target_foo, &target_bar};
-  std::vector<const Pool*> all_pools = {&swiming_pool};
-  NinjaBuildWriter writer(setup.build_settings(), all_settings,
-                          setup.toolchain(), targets, all_pools, ninja_out,
-                          depfile_out);
+
+  NinjaBuildWriter writer(setup.build_settings(), used_toolchains,
+                          setup.toolchain(), targets, ninja_out, depfile_out);
   ASSERT_TRUE(writer.Run(&err));
 
   const char expected_rule_gn[] = "rule gn\n";
   const char expected_build_ninja[] =
       "build build.ninja: gn\n"
       "  generator = 1\n"
-      "  depfile = build.ninja.d\n"
-      "\n";
+      "  depfile = build.ninja.d\n";
   const char expected_link_pool[] =
       "pool link_pool\n"
-      "  depth = 0\n"
-      "\n"
-      "pool other_toolchain_swiming_pool\n"
-      "  depth = 42\n"
-      "\n";
+      "  depth = 0\n";
+  const char expected_other_pool[] =
+      "pool other_toolchain_other_pool\n"
+      "  depth = 42\n";
   const char expected_toolchain[] =
-      "subninja toolchain.ninja\n"
-      "\n";
+      "subninja toolchain.ninja\n";
   const char expected_targets[] =
       "build bar: phony obj/bar/bar.stamp\n"
       "build foo$:bar: phony obj/foo/bar.stamp\n"
-      "build bar$:bar: phony obj/bar/bar.stamp\n"
-      "\n";
+      "build bar$:bar: phony obj/bar/bar.stamp\n";
   const char expected_root_target[] =
       "build all: phony $\n"
       "    obj/foo/bar.stamp $\n"
-      "    obj/bar/bar.stamp\n"
-      "\n"
+      "    obj/bar/bar.stamp\n";
+  const char expected_default[] =
       "default all\n";
   std::string out_str = ninja_out.str();
 #define EXPECT_SNIPPET(expected) \
@@ -82,9 +92,11 @@
   EXPECT_SNIPPET(expected_rule_gn);
   EXPECT_SNIPPET(expected_build_ninja);
   EXPECT_SNIPPET(expected_link_pool);
+  EXPECT_SNIPPET(expected_other_pool);
   EXPECT_SNIPPET(expected_toolchain);
   EXPECT_SNIPPET(expected_targets);
   EXPECT_SNIPPET(expected_root_target);
+  EXPECT_SNIPPET(expected_default);
 #undef EXPECT_SNIPPET
 }
 
@@ -109,14 +121,13 @@
   target_bar.SetToolchain(setup.toolchain());
   ASSERT_TRUE(target_bar.OnResolved(&err));
 
+  std::map<const Settings*, const Toolchain*> used_toolchains;
+  used_toolchains[setup.settings()] = setup.toolchain();
+  std::vector<const Target*> targets = { &target_foo, &target_bar };
   std::ostringstream ninja_out;
   std::ostringstream depfile_out;
-  std::vector<const Settings*> all_settings = { setup.settings() };
-  std::vector<const Target*> targets = { &target_foo, &target_bar };
-  std::vector<const Pool*> all_pools;
-  NinjaBuildWriter writer(setup.build_settings(), all_settings,
-                          setup.toolchain(), targets, all_pools, ninja_out,
-                          depfile_out);
+  NinjaBuildWriter writer(setup.build_settings(), used_toolchains,
+                          setup.toolchain(), targets, ninja_out, depfile_out);
   ASSERT_FALSE(writer.Run(&err));
 
   const char expected_help_test[] =
diff --git a/tools/gn/ninja_target_writer.cc b/tools/gn/ninja_target_writer.cc
index 69e9d90..ccb3eb7 100644
--- a/tools/gn/ninja_target_writer.cc
+++ b/tools/gn/ninja_target_writer.cc
@@ -39,50 +39,82 @@
 }
 
 // static
-void NinjaTargetWriter::RunAndWriteFile(const Target* target) {
+std::string NinjaTargetWriter::RunAndWriteFile(const Target* target) {
   const Settings* settings = target->settings();
 
   ScopedTrace trace(TraceItem::TRACE_FILE_WRITE,
                     target->label().GetUserVisibleName(false));
   trace.SetToolchain(settings->toolchain_label());
 
-  base::FilePath ninja_file(settings->build_settings()->GetFullPath(
-      GetNinjaFileForTarget(target)));
-
   if (g_scheduler->verbose_logging())
-    g_scheduler->Log("Writing", FilePathToUTF8(ninja_file));
-
-  base::CreateDirectory(ninja_file.DirName());
+    g_scheduler->Log("Computing", target->label().GetUserVisibleName(true));
 
   // It's ridiculously faster to write to a string and then write that to
   // disk in one operation than to use an fstream here.
-  std::stringstream file;
+  std::stringstream rules;
 
-  // Call out to the correct sub-type of writer.
+  // Call out to the correct sub-type of writer. Binary targets need to be
+  // written to separate files for compiler flag scoping, but other target
+  // types can have their rules coalesced.
+  //
+  // In ninja, if a rule uses a variable (like $include_dirs) it will use
+  // the value set by indenting it under the build line or it takes the value
+  // from the end of the invoking scope (otherwise the current file). It does
+  // not copy the value from what it was when the build line was encountered.
+  // To avoid writing lots of duplicate rules for defines and cflags, etc. on
+  // each source file build line, we use separate .ninja files with the shared
+  // variables set at the top.
+  //
+  // Groups and actions don't use this type of flag, they make unique rules
+  // or write variables scoped under each build line. As a result, they don't
+  // need the separate files.
+  bool needs_file_write = false;
   if (target->output_type() == Target::BUNDLE_DATA) {
-    NinjaBundleDataTargetWriter writer(target, file);
+    NinjaBundleDataTargetWriter writer(target, rules);
     writer.Run();
   } else if (target->output_type() == Target::CREATE_BUNDLE) {
-    NinjaCreateBundleTargetWriter writer(target, file);
+    NinjaCreateBundleTargetWriter writer(target, rules);
     writer.Run();
   } else if (target->output_type() == Target::COPY_FILES) {
-    NinjaCopyTargetWriter writer(target, file);
+    NinjaCopyTargetWriter writer(target, rules);
     writer.Run();
   } else if (target->output_type() == Target::ACTION ||
              target->output_type() == Target::ACTION_FOREACH) {
-    NinjaActionTargetWriter writer(target, file);
+    NinjaActionTargetWriter writer(target, rules);
     writer.Run();
   } else if (target->output_type() == Target::GROUP) {
-    NinjaGroupTargetWriter writer(target, file);
+    NinjaGroupTargetWriter writer(target, rules);
     writer.Run();
   } else if (target->IsBinary()) {
-    NinjaBinaryTargetWriter writer(target, file);
+    needs_file_write = true;
+    NinjaBinaryTargetWriter writer(target, rules);
     writer.Run();
   } else {
     CHECK(0) << "Output type of target not handled.";
   }
 
-  WriteFileIfChanged(ninja_file, file.str(), nullptr);
+  if (needs_file_write) {
+    // Write the ninja file.
+    SourceFile ninja_file = GetNinjaFileForTarget(target);
+    base::FilePath full_ninja_file =
+        settings->build_settings()->GetFullPath(ninja_file);
+    base::CreateDirectory(full_ninja_file.DirName());
+    WriteFileIfChanged(full_ninja_file, rules.str(), nullptr);
+
+    EscapeOptions options;
+    options.mode = ESCAPE_NINJA;
+
+    // Return the subninja command to load the rules file.
+    std::string result = "subninja ";
+    result.append(EscapeString(
+        OutputFile(target->settings()->build_settings(), ninja_file).value(),
+                   options, nullptr));
+    result.push_back('\n');
+    return result;
+  }
+
+  // No separate file required, just return the rules.
+  return rules.str();
 }
 
 void NinjaTargetWriter::WriteEscapedSubstitution(SubstitutionType type) {
diff --git a/tools/gn/ninja_target_writer.h b/tools/gn/ninja_target_writer.h
index 0248b07..72ecbca 100644
--- a/tools/gn/ninja_target_writer.h
+++ b/tools/gn/ninja_target_writer.h
@@ -24,7 +24,14 @@
   NinjaTargetWriter(const Target* target, std::ostream& out);
   virtual ~NinjaTargetWriter();
 
-  static void RunAndWriteFile(const Target* target);
+  // Returns the build line to be written to the toolchain build file.
+  //
+  // Some targets have their rules written to separate files, and some can have
+  // their rules coalesced in the main build file. For the coalesced case, this
+  // function will return the rules as a string. For the separate file case,
+  // the separate ninja file will be written and the return string will be the
+  // subninja command to load that file.
+  static std::string RunAndWriteFile(const Target* target);
 
   virtual void Run() = 0;
 
diff --git a/tools/gn/ninja_toolchain_writer.cc b/tools/gn/ninja_toolchain_writer.cc
index 9b699b8..40653a8 100644
--- a/tools/gn/ninja_toolchain_writer.cc
+++ b/tools/gn/ninja_toolchain_writer.cc
@@ -27,11 +27,9 @@
 NinjaToolchainWriter::NinjaToolchainWriter(
     const Settings* settings,
     const Toolchain* toolchain,
-    const std::vector<const Target*>& targets,
     std::ostream& out)
     : settings_(settings),
       toolchain_(toolchain),
-      targets_(targets),
       out_(out),
       path_output_(settings_->build_settings()->build_dir(),
                    settings_->build_settings()->root_path_utf8(),
@@ -41,16 +39,27 @@
 NinjaToolchainWriter::~NinjaToolchainWriter() {
 }
 
-void NinjaToolchainWriter::Run() {
-  WriteRules();
-  WriteSubninjas();
+void NinjaToolchainWriter::Run(
+    const std::vector<NinjaWriter::TargetRulePair>& rules) {
+  std::string rule_prefix = GetNinjaRulePrefixForToolchain(settings_);
+
+  for (int i = Toolchain::TYPE_NONE + 1; i < Toolchain::TYPE_NUMTYPES; i++) {
+    Toolchain::ToolType tool_type = static_cast<Toolchain::ToolType>(i);
+    const Tool* tool = toolchain_->GetTool(tool_type);
+    if (tool)
+      WriteToolRule(tool_type, tool, rule_prefix);
+  }
+  out_ << std::endl;
+
+  for (const auto& pair : rules)
+    out_ << pair.second;
 }
 
 // static
 bool NinjaToolchainWriter::RunAndWriteFile(
     const Settings* settings,
     const Toolchain* toolchain,
-    const std::vector<const Target*>& targets) {
+    const std::vector<NinjaWriter::TargetRulePair>& rules) {
   base::FilePath ninja_file(settings->build_settings()->GetFullPath(
       GetNinjaFileForToolchain(settings)));
   ScopedTrace trace(TraceItem::TRACE_FILE_WRITE, FilePathToUTF8(ninja_file));
@@ -63,23 +72,11 @@
   if (file.fail())
     return false;
 
-  NinjaToolchainWriter gen(settings, toolchain, targets, file);
-  gen.Run();
+  NinjaToolchainWriter gen(settings, toolchain, file);
+  gen.Run(rules);
   return true;
 }
 
-void NinjaToolchainWriter::WriteRules() {
-  std::string rule_prefix = GetNinjaRulePrefixForToolchain(settings_);
-
-  for (int i = Toolchain::TYPE_NONE + 1; i < Toolchain::TYPE_NUMTYPES; i++) {
-    Toolchain::ToolType tool_type = static_cast<Toolchain::ToolType>(i);
-    const Tool* tool = toolchain_->GetTool(tool_type);
-    if (tool)
-      WriteToolRule(tool_type, tool, rule_prefix);
-  }
-  out_ << std::endl;
-}
-
 void NinjaToolchainWriter::WriteToolRule(const Toolchain::ToolType type,
                                          const Tool* tool,
                                          const std::string& rule_prefix) {
@@ -133,15 +130,3 @@
   SubstitutionWriter::WriteWithNinjaVariables(pattern, options, out_);
   out_ << std::endl;
 }
-
-void NinjaToolchainWriter::WriteSubninjas() {
-  // Write subninja commands for each generated target.
-  for (auto* target : targets_) {
-    OutputFile ninja_file(target->settings()->build_settings(),
-                          GetNinjaFileForTarget(target));
-    out_ << "subninja ";
-    path_output_.WriteFile(out_, ninja_file);
-    out_ << std::endl;
-  }
-  out_ << std::endl;
-}
diff --git a/tools/gn/ninja_toolchain_writer.h b/tools/gn/ninja_toolchain_writer.h
index a1e39c3..9ddde84 100644
--- a/tools/gn/ninja_toolchain_writer.h
+++ b/tools/gn/ninja_toolchain_writer.h
@@ -12,6 +12,7 @@
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
+#include "tools/gn/ninja_writer.h"
 #include "tools/gn/path_output.h"
 #include "tools/gn/toolchain.h"
 
@@ -25,20 +26,20 @@
  public:
   // Takes the settings for the toolchain, as well as the list of all targets
   // associated with the toolchain.
-  static bool RunAndWriteFile(const Settings* settings,
-                              const Toolchain* toolchain,
-                              const std::vector<const Target*>& targets);
+  static bool RunAndWriteFile(
+      const Settings* settings,
+      const Toolchain* toolchain,
+      const std::vector<NinjaWriter::TargetRulePair>& rules);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(NinjaToolchainWriter, WriteToolRule);
 
   NinjaToolchainWriter(const Settings* settings,
                        const Toolchain* toolchain,
-                       const std::vector<const Target*>& targets,
                        std::ostream& out);
   ~NinjaToolchainWriter();
 
-  void Run();
+  void Run(const std::vector<NinjaWriter::TargetRulePair>& extra_rules);
 
   void WriteRules();
   void WriteToolRule(Toolchain::ToolType type,
@@ -47,11 +48,9 @@
   void WriteRulePattern(const char* name,
                         const SubstitutionPattern& pattern,
                         const EscapeOptions& options);
-  void WriteSubninjas();
 
   const Settings* settings_;
   const Toolchain* toolchain_;
-  std::vector<const Target*> targets_;
   std::ostream& out_;
   PathOutput path_output_;
 
diff --git a/tools/gn/ninja_toolchain_writer_unittest.cc b/tools/gn/ninja_toolchain_writer_unittest.cc
index fc52f7d..4e9d767 100644
--- a/tools/gn/ninja_toolchain_writer_unittest.cc
+++ b/tools/gn/ninja_toolchain_writer_unittest.cc
@@ -11,14 +11,8 @@
 TEST(NinjaToolchainWriter, WriteToolRule) {
   TestWithScope setup;
 
-  //Target target(setup.settings(), Label(SourceDir("//foo/"), "target"));
-  //target.set_output_type(Target::EXECUTABLE);
-  //target.SetToolchain(setup.toolchain());
-
   std::ostringstream stream;
-
-  NinjaToolchainWriter writer(setup.settings(), setup.toolchain(),
-                              std::vector<const Target*>(), stream);
+  NinjaToolchainWriter writer(setup.settings(), setup.toolchain(), stream);
   writer.WriteToolRule(Toolchain::TYPE_CC,
                        setup.toolchain()->GetTool(Toolchain::TYPE_CC),
                        std::string("prefix_"));
diff --git a/tools/gn/ninja_writer.cc b/tools/gn/ninja_writer.cc
index 22a97ec..4fd5b22 100644
--- a/tools/gn/ninja_writer.cc
+++ b/tools/gn/ninja_writer.cc
@@ -12,118 +12,45 @@
 #include "tools/gn/settings.h"
 #include "tools/gn/target.h"
 
-NinjaWriter::NinjaWriter(const BuildSettings* build_settings,
-                         Builder* builder)
-    : build_settings_(build_settings),
-      builder_(builder) {
+NinjaWriter::NinjaWriter(const Builder& builder)
+    : builder_(builder) {
 }
 
 NinjaWriter::~NinjaWriter() {
 }
 
 // static
-bool NinjaWriter::RunAndWriteFiles(const BuildSettings* build_settings,
-                                   Builder* builder,
-                                   Err* err) {
-  NinjaWriter writer(build_settings, builder);
-
-  std::vector<const Settings*> all_settings;
-  std::vector<const Target*> default_targets;
-  std::vector<const Pool*> all_pools;
-  if (!writer.WriteToolchains(&all_settings, &default_targets, &all_pools, err))
-    return false;
-  return writer.WriteRootBuildfiles(all_settings, default_targets, all_pools,
-                                    err);
-}
-
-// static
-bool NinjaWriter::RunAndWriteToolchainFiles(
+bool NinjaWriter::RunAndWriteFiles(
     const BuildSettings* build_settings,
-    Builder* builder,
-    std::vector<const Settings*>* all_settings,
+    const Builder& builder,
+    const PerToolchainRules& per_toolchain_rules,
     Err* err) {
-  NinjaWriter writer(build_settings, builder);
-  std::vector<const Target*> default_targets;
-  std::vector<const Pool*> all_pools;
-  return writer.WriteToolchains(all_settings, &default_targets, &all_pools,
-                                err);
+  NinjaWriter writer(builder);
+
+  if (!writer.WriteToolchains(per_toolchain_rules, err))
+    return false;
+  return NinjaBuildWriter::RunAndWriteFile(build_settings, builder, err);
 }
 
-bool NinjaWriter::WriteToolchains(std::vector<const Settings*>* all_settings,
-                                  std::vector<const Target*>* default_targets,
-                                  std::vector<const Pool*>* all_pools,
+bool NinjaWriter::WriteToolchains(const PerToolchainRules& per_toolchain_rules,
                                   Err* err) {
-  // Categorize all targets by toolchain.
-  typedef std::map<Label, std::vector<const Target*> > CategorizedMap;
-  CategorizedMap categorized;
-
-  std::vector<const BuilderRecord*> all_records = builder_->GetAllRecords();
-  for (auto* all_record : all_records) {
-    if (all_record->type() == BuilderRecord::ITEM_TARGET &&
-        all_record->should_generate()) {
-      categorized[all_record->label().GetToolchainLabel()].push_back(
-          all_record->item()->AsTarget());
-      }
-  }
-  if (categorized.empty()) {
+  if (per_toolchain_rules.empty()) {
     Err(Location(), "No targets.",
         "I could not find any targets to write, so I'm doing nothing.")
         .PrintToStdout();
     return false;
   }
 
-  for (auto& i : categorized) {
-    // Sort targets so that they are in a deterministic order.
-    std::sort(i.second.begin(), i.second.end(),
-              [](const Target* a, const Target* b) {
-                return a->label() < b->label();
-              });
-  }
-
-  Label default_label = builder_->loader()->GetDefaultToolchain();
-
-  // Write out the toolchain buildfiles, and also accumulate the set of
-  // all settings and find the list of targets in the default toolchain.
-  UniqueVector<const Pool*> pools;
-  for (const auto& i : categorized) {
+  for (const auto& i : per_toolchain_rules) {
+    const Toolchain* toolchain = i.first;
     const Settings* settings =
-        builder_->loader()->GetToolchainSettings(i.first);
-    const Toolchain* toolchain = builder_->GetToolchain(i.first);
-
-    all_settings->push_back(settings);
-
+        builder_.loader()->GetToolchainSettings(toolchain->label());
     if (!NinjaToolchainWriter::RunAndWriteFile(settings, toolchain, i.second)) {
       Err(Location(),
           "Couldn't open toolchain buildfile(s) for writing").PrintToStdout();
       return false;
     }
-
-    for (int j = Toolchain::TYPE_NONE + 1; j < Toolchain::TYPE_NUMTYPES; j++) {
-      Toolchain::ToolType tool_type = static_cast<Toolchain::ToolType>(j);
-      const Tool* tool = toolchain->GetTool(tool_type);
-      if (tool && tool->pool().ptr)
-        pools.push_back(tool->pool().ptr);
-    }
   }
 
-  *all_pools = pools.vector();
-  *default_targets = categorized[default_label];
   return true;
 }
-
-bool NinjaWriter::WriteRootBuildfiles(
-    const std::vector<const Settings*>& all_settings,
-    const std::vector<const Target*>& default_targets,
-    const std::vector<const Pool*>& all_pools,
-    Err* err) {
-  // All Settings objects should have the same default toolchain, and there
-  // should always be at least one settings object in the build.
-  CHECK(!all_settings.empty());
-  const Toolchain* default_toolchain =
-      builder_->GetToolchain(all_settings[0]->default_toolchain_label());
-
-  // Write the root buildfile.
-  return NinjaBuildWriter::RunAndWriteFile(build_settings_, all_settings,
-                                           default_toolchain, default_targets,
-                                           all_pools, err);
-}
diff --git a/tools/gn/ninja_writer.h b/tools/gn/ninja_writer.h
index ea8fc47..4bcbf36 100644
--- a/tools/gn/ninja_writer.h
+++ b/tools/gn/ninja_writer.h
@@ -5,6 +5,7 @@
 #ifndef TOOLS_GN_NINJA_WRITER_H_
 #define TOOLS_GN_NINJA_WRITER_H_
 
+#include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ -17,37 +18,34 @@
 class Pool;
 class Settings;
 class Target;
+class Toolchain;
 
 class NinjaWriter {
  public:
-  // On failure will populate |err| and will return false.
-  static bool RunAndWriteFiles(const BuildSettings* build_settings,
-                               Builder* builder,
-                               Err* err);
+  // Combines a target and the computed build rule for it.
+  using TargetRulePair = std::pair<const Target*, std::string>;
 
-  // Writes only the toolchain.ninja files, skipping the root buildfile. The
-  // settings for the files written will be added to the vector.
-  static bool RunAndWriteToolchainFiles(
+  // Associates the build rules with each toolchain.
+  using PerToolchainRules =
+      std::map<const Toolchain*, std::vector<TargetRulePair>>;
+
+  // On failure will populate |err| and will return false.  The map contains
+  // the per-toolchain set of rules collected to write to the toolchain build
+  // files.
+  static bool RunAndWriteFiles(
       const BuildSettings* build_settings,
-      Builder* builder,
-      std::vector<const Settings*>* all_settings,
+      const Builder& builder,
+      const PerToolchainRules& per_toolchain_rules,
       Err* err);
 
  private:
-  NinjaWriter(const BuildSettings* build_settings, Builder* builder);
+  NinjaWriter(const Builder& builder);
   ~NinjaWriter();
 
-  bool WriteToolchains(std::vector<const Settings*>* all_settings,
-                       std::vector<const Target*>* default_targets,
-                       std::vector<const Pool*>* all_pools,
+  bool WriteToolchains(const PerToolchainRules& per_toolchain_rules,
                        Err* err);
-  bool WriteRootBuildfiles(const std::vector<const Settings*>& all_settings,
-                           const std::vector<const Target*>& default_targets,
-                           const std::vector<const Pool*>& all_pools,
-                           Err* err);
 
-  const BuildSettings* build_settings_;
-  Builder* builder_;
+  const Builder& builder_;
 
   DISALLOW_COPY_AND_ASSIGN(NinjaWriter);
 };
diff --git a/tools/gn/qt_creator_writer.cc b/tools/gn/qt_creator_writer.cc
index 96f247f..db0c9b8 100644
--- a/tools/gn/qt_creator_writer.cc
+++ b/tools/gn/qt_creator_writer.cc
@@ -32,7 +32,7 @@
 
 // static
 bool QtCreatorWriter::RunAndWriteFile(const BuildSettings* build_settings,
-                                      const Builder* builder,
+                                      const Builder& builder,
                                       Err* err,
                                       const std::string& root_target) {
   base::FilePath project_dir =
@@ -60,7 +60,7 @@
 }
 
 QtCreatorWriter::QtCreatorWriter(const BuildSettings* build_settings,
-                                 const Builder* builder,
+                                 const Builder& builder,
                                  const base::FilePath& project_prefix,
                                  const std::string& root_target_name)
     : build_settings_(build_settings),
@@ -81,7 +81,7 @@
 }
 
 bool QtCreatorWriter::DiscoverTargets() {
-  auto all_targets = builder_->GetAllResolvedTargets();
+  auto all_targets = builder_.GetAllResolvedTargets();
 
   if (root_target_name_.empty()) {
     targets_ = std::set<const Target*>(all_targets.begin(), all_targets.end());
@@ -160,7 +160,7 @@
 
   for (const Target* target : targets_) {
     if (target->toolchain()->label() !=
-        builder_->loader()->GetDefaultToolchain())
+        builder_.loader()->GetDefaultToolchain())
       continue;
     HandleTarget(target);
   }
diff --git a/tools/gn/qt_creator_writer.h b/tools/gn/qt_creator_writer.h
index cea75fd..cb37404 100644
--- a/tools/gn/qt_creator_writer.h
+++ b/tools/gn/qt_creator_writer.h
@@ -19,13 +19,13 @@
 class QtCreatorWriter {
  public:
   static bool RunAndWriteFile(const BuildSettings* build_settings,
-                              const Builder* builder,
+                              const Builder& builder,
                               Err* err,
                               const std::string& root_target);
 
  private:
   QtCreatorWriter(const BuildSettings* build_settings,
-                  const Builder* builder,
+                  const Builder& builder,
                   const base::FilePath& project_prefix,
                   const std::string& root_target_name);
   ~QtCreatorWriter();
@@ -41,7 +41,7 @@
                     const std::set<std::string>& items);
 
   const BuildSettings* build_settings_;
-  const Builder* builder_;
+  const Builder& builder_;
   base::FilePath project_prefix_;
   std::string root_target_name_;
   std::set<const Target*> targets_;
diff --git a/tools/gn/settings.h b/tools/gn/settings.h
index 9192551..91f6410 100644
--- a/tools/gn/settings.h
+++ b/tools/gn/settings.h
@@ -39,6 +39,10 @@
 
   const BuildSettings* build_settings() const { return build_settings_; }
 
+  // The actual Toolchain object pointer is not available on the settings
+  // object because it might not be resolved yet. Code running after the
+  // load is complete can ask the Builder for the Toolchain corresponding to
+  // this label.
   const Label& toolchain_label() const { return toolchain_label_; }
   void set_toolchain_label(const Label& l) { toolchain_label_ = l; }
 
diff --git a/tools/gn/setup.cc b/tools/gn/setup.cc
index 60aeaa8..490204d 100644
--- a/tools/gn/setup.cc
+++ b/tools/gn/setup.cc
@@ -142,11 +142,14 @@
 // Called on any thread. Post the item to the builder on the main thread.
 void ItemDefinedCallback(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    scoped_refptr<Builder> builder,
+    Builder* builder_call_on_main_thread_only,
     std::unique_ptr<Item> item) {
   DCHECK(item);
-  task_runner->PostTask(FROM_HERE, base::Bind(&Builder::ItemDefined, builder,
-                                              base::Passed(&item)));
+  task_runner->PostTask(
+      FROM_HERE,
+      base::Bind(&Builder::ItemDefined,
+                 base::Unretained(builder_call_on_main_thread_only),
+                 base::Passed(&item)));
 }
 
 void DecrementWorkCount() {
@@ -251,7 +254,7 @@
 Setup::Setup()
     : build_settings_(),
       loader_(new LoaderImpl(&build_settings_)),
-      builder_(new Builder(loader_.get())),
+      builder_(loader_.get()),
       root_build_file_("//BUILD.gn"),
       check_public_headers_(false),
       dotfile_settings_(&build_settings_, std::string()),
@@ -259,7 +262,7 @@
       fill_arguments_(true) {
   dotfile_settings_.set_toolchain_label(Label());
   build_settings_.set_item_defined_callback(
-      base::Bind(&ItemDefinedCallback, scheduler_.task_runner(), builder_));
+      base::Bind(&ItemDefinedCallback, scheduler_.task_runner(), &builder_));
 
   loader_->set_complete_callback(base::Bind(&DecrementWorkCount));
   // The scheduler's task runner wasn't created when the Loader was created, so
@@ -329,7 +332,7 @@
 bool Setup::RunPostMessageLoop() {
   Err err;
   if (build_settings_.check_for_bad_items()) {
-    if (!builder_->CheckForBadItems(&err)) {
+    if (!builder_.CheckForBadItems(&err)) {
       err.PrintToStdout();
       return false;
     }
@@ -347,7 +350,7 @@
   }
 
   if (check_public_headers_) {
-    std::vector<const Target*> all_targets = builder_->GetAllResolvedTargets();
+    std::vector<const Target*> all_targets = builder_.GetAllResolvedTargets();
     std::vector<const Target*> to_check;
     if (check_patterns()) {
       commands::FilterTargetsByPatterns(all_targets, *check_patterns(),
diff --git a/tools/gn/setup.h b/tools/gn/setup.h
index 22e6557..45335bf 100644
--- a/tools/gn/setup.h
+++ b/tools/gn/setup.h
@@ -82,7 +82,7 @@
   }
 
   BuildSettings& build_settings() { return build_settings_; }
-  Builder* builder() { return builder_.get(); }
+  Builder& builder() { return builder_; }
   LoaderImpl* loader() { return loader_.get(); }
 
   // Name of the file in the root build directory that contains the build
@@ -128,7 +128,7 @@
 
   BuildSettings build_settings_;
   scoped_refptr<LoaderImpl> loader_;
-  scoped_refptr<Builder> builder_;
+  Builder builder_;
 
   SourceFile root_build_file_;
 
diff --git a/tools/gn/toolchain.h b/tools/gn/toolchain.h
index 76858de..4ccfdc8 100644
--- a/tools/gn/toolchain.h
+++ b/tools/gn/toolchain.h
@@ -66,6 +66,15 @@
   static const char* kToolCopyBundleData;
   static const char* kToolCompileXCAssets;
 
+  // The Settings of an Item is always the context in which the Item was
+  // defined. For a toolchain this is confusing because this is NOT the
+  // settings object that applies to the things in the toolchain.
+  //
+  // To get the Settings object corresponding to objects loaded in the context
+  // of this toolchain (probably what you want instead), see
+  // Loader::GetToolchainSettings(). Many toolchain objects may be created in a
+  // given build, but only a few might be used, and the Loader is in charge of
+  // this process.
   Toolchain(const Settings* settings, const Label& label);
   ~Toolchain() override;
 
diff --git a/tools/gn/visual_studio_writer.cc b/tools/gn/visual_studio_writer.cc
index 401782f..fb6d923 100644
--- a/tools/gn/visual_studio_writer.cc
+++ b/tools/gn/visual_studio_writer.cc
@@ -166,12 +166,12 @@
 }
 
 bool FilterTargets(const BuildSettings* build_settings,
-                   Builder* builder,
+                   const Builder& builder,
                    const std::string& dir_filters,
                    std::vector<const Target*>* targets,
                    Err* err) {
   if (dir_filters.empty()) {
-    *targets = builder->GetAllResolvedTargets();
+    *targets = builder.GetAllResolvedTargets();
     return true;
   }
 
@@ -180,7 +180,7 @@
                                           err))
     return false;
 
-  commands::FilterTargetsByPatterns(builder->GetAllResolvedTargets(), filters,
+  commands::FilterTargetsByPatterns(builder.GetAllResolvedTargets(), filters,
                                     targets);
 
   std::set<Label> labels;
@@ -269,7 +269,7 @@
 
 // static
 bool VisualStudioWriter::RunAndWriteFiles(const BuildSettings* build_settings,
-                                          Builder* builder,
+                                          const Builder& builder,
                                           Version version,
                                           const std::string& sln_name,
                                           const std::string& dir_filters,
diff --git a/tools/gn/visual_studio_writer.h b/tools/gn/visual_studio_writer.h
index 99c5370..0a8fcb4 100644
--- a/tools/gn/visual_studio_writer.h
+++ b/tools/gn/visual_studio_writer.h
@@ -37,7 +37,7 @@
   // of generated projects. Only matching targets will be included to the
   // solution. On failure will populate |err| and will return false.
   static bool RunAndWriteFiles(const BuildSettings* build_settings,
-                               Builder* builder,
+                               const Builder& builder,
                                Version version,
                                const std::string& sln_name,
                                const std::string& dir_filters,
diff --git a/tools/gn/xcode_writer.cc b/tools/gn/xcode_writer.cc
index d60f4f7..e6b66d5 100644
--- a/tools/gn/xcode_writer.cc
+++ b/tools/gn/xcode_writer.cc
@@ -145,7 +145,7 @@
                                    const std::string& ninja_extra_args,
                                    const std::string& dir_filters_string,
                                    const BuildSettings* build_settings,
-                                   Builder* builder,
+                                   const Builder& builder,
                                    Err* err) {
   const XcodeWriter::TargetOsType target_os =
       GetTargetOs(build_settings->build_args());
@@ -180,7 +180,7 @@
     config_name = config_name.substr(0, separator);
 
   std::vector<const Target*> targets;
-  std::vector<const Target*> all_targets = builder->GetAllResolvedTargets();
+  std::vector<const Target*> all_targets = builder.GetAllResolvedTargets();
   if (!XcodeWriter::FilterTargets(build_settings, all_targets,
                                   dir_filters_string, &targets, err)) {
     return false;
diff --git a/tools/gn/xcode_writer.h b/tools/gn/xcode_writer.h
index 8c4e304..5148788 100644
--- a/tools/gn/xcode_writer.h
+++ b/tools/gn/xcode_writer.h
@@ -48,7 +48,7 @@
                                const std::string& ninja_extra_args,
                                const std::string& dir_filters_string,
                                const BuildSettings* build_settings,
-                               Builder* builder,
+                               const Builder& builder,
                                Err* err);
 
  private: