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

tools/gn/qt_creator_writer.cc

 // Copyright (c) 2016 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/qt_creator_writer.h"
 
 #include <set>
 #include <sstream>
 #include <string>
 
@@ skipping 14 matching lines @@
 base::FilePath::CharType kProjectName[] = FILE_PATH_LITERAL("all");
 base::FilePath::CharType kMainProjectFileSuffix[] =
     FILE_PATH_LITERAL(".creator");
 base::FilePath::CharType kSourcesFileSuffix[] = FILE_PATH_LITERAL(".files");
 base::FilePath::CharType kIncludesFileSuffix[] = FILE_PATH_LITERAL(".includes");
 base::FilePath::CharType kDefinesFileSuffix[] = FILE_PATH_LITERAL(".config");
 }
 
 // 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 =
       build_settings->GetFullPath(build_settings->build_dir())
           .Append(kProjectDirName);
   if (!base::DirectoryExists(project_dir)) {
     base::File::Error error;
     if (!base::CreateDirectoryAndGetError(project_dir, &error)) {
       *err =
           Err(Location(), "Could not create the QtCreator project directory '" +
                               FilePathToUTF8(project_dir) + "': " +
                               base::File::ErrorToString(error));
       return false;
     }
   }
 
   base::FilePath project_prefix = project_dir.Append(kProjectName);
   QtCreatorWriter gen(build_settings, builder, project_prefix, root_target);
   gen.Run();
   if (gen.err_.has_error()) {
     *err = gen.err_;
     return false;
   }
   return true;
 }
 
 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),
       builder_(builder),
       project_prefix_(project_prefix),
       root_target_name_(root_target_name) {}
 
 QtCreatorWriter::~QtCreatorWriter() {}
 
 void QtCreatorWriter::CollectDeps(const Target* target) {
   for (const auto& dep : target->GetDeps(Target::DEPS_ALL)) {
     const Target* dep_target = dep.ptr;
     if (targets_.count(dep_target))
       continue;
     targets_.insert(dep_target);
     CollectDeps(dep_target);
   }
 }
 
 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());
     return true;
   }
 
   const Target* root_target = nullptr;
   for (const Target* target : all_targets) {
     if (target->label().name() == root_target_name_) {
       root_target = target;
@@ skipping 58 matching lines @@
     output << item << std::endl;
   WriteFileIfChanged(file_path, output.str(), &err_);
 }
 
 void QtCreatorWriter::Run() {
   if (!DiscoverTargets())
     return;
 
   for (const Target* target : targets_) {
     if (target->toolchain()->label() !=
-        builder_->loader()->GetDefaultToolchain())
+        builder_.loader()->GetDefaultToolchain())
       continue;
     HandleTarget(target);
   }
 
   std::set<std::string> empty_list;
 
   GenerateFile(kMainProjectFileSuffix, empty_list);
   GenerateFile(kSourcesFileSuffix, sources_);
   GenerateFile(kIncludesFileSuffix, includes_);
   GenerateFile(kDefinesFileSuffix, defines_);
 }