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

tools/gn/setup.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/setup.h"
 
 #include <stdlib.h>
 #include <algorithm>
 #include <sstream>
 #include <utility>
@@ skipping 124 matching lines @@
   base::FilePath up_one_dir = with_no_slash.DirName();
   if (up_one_dir == current_dir)
     return base::FilePath();  // Got to the top.
 
   return FindDotFile(up_one_dir);
 }
 
 // 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() {
   g_scheduler->DecrementWorkCount();
 }
 
 #if defined(OS_WIN)
 
 // Given the path to a batch file that runs Python, extracts the name of the
 // executable actually implementing Python. Generally people write a batch file
@@ skipping 84 matching lines @@
   return true;
 }
 
 }  // namespace
 
 const char Setup::kBuildArgFileName[] = "args.gn";
 
 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()),
       dotfile_scope_(&dotfile_settings_),
       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
   // we need to set it now.
   loader_->set_task_runner(scheduler_.task_runner());
 }
 
 Setup::~Setup() {
 }
 
@@ skipping 49 matching lines @@
   // Load the root build file.
   loader_->Load(root_build_file_, LocationRange(), Label());
 
   // Will be decremented with the loader is drained.
   g_scheduler->IncrementWorkCount();
 }
 
 bool Setup::RunPostMessageLoop() {
   Err err;
   if (build_settings_.check_for_bad_items()) {
-    if (!builder_->CheckForBadItems(&err)) {
+    if (!builder_.CheckForBadItems(&err)) {
       err.PrintToStdout();
       return false;
     }
 
     if (!build_settings_.build_args().VerifyAllOverridesUsed(&err)) {
       // TODO(brettw) implement a system to have a different marker for
       // warnings. Until we have a better system, print the error but don't
       // return failure unless requested on the command line.
       err.PrintToStdout();
       if (base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kFailOnUnusedArgs))
         return false;
       return true;
     }
   }
 
   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(),
                                         &to_check);
     } else {
       to_check = all_targets;
     }
 
     if (!commands::CheckPublicHeaders(&build_settings_, all_targets,
                                       to_check, false)) {
@@ skipping 373 matching lines @@
       if (err.has_error()) {
         err.PrintToStdout();
         return false;
       }
     }
     build_settings_.set_exec_script_whitelist(std::move(whitelist));
   }
 
   return true;
 }