Generate VS projects also for target dependencies.

tools/gn/visual_studio_writer.cc

 // Copyright 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/visual_studio_writer.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 #include <memory>
+#include <queue>
 #include <set>
 #include <string>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "tools/gn/builder.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/config.h"
 #include "tools/gn/config_values_extractors.h"
+#include "tools/gn/deps_iterator.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/label_pattern.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/path_output.h"
 #include "tools/gn/source_file_type.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/target.h"
 #include "tools/gn/variables.h"
 #include "tools/gn/visual_studio_utils.h"
 #include "tools/gn/xml_element_writer.h"
@@ skipping 125 matching lines @@
 // outlive the output.
 base::StringPiece FindParentDir(const std::string* path) {
   DCHECK(path && !path->empty());
   for (int i = static_cast<int>(path->size()) - 2; i >= 0; --i) {
     if (IsSlash((*path)[i]))
       return base::StringPiece(path->data(), i);
   }
   return base::StringPiece();
 }
 
+bool FilterTargets(const BuildSettings* build_settings,
+                   Builder* builder,
+                   const std::string& dir_filters,
+                   std::vector<const Target*>* targets,
+                   Err* err) {
+  if (dir_filters.empty()) {
+    *targets = builder->GetAllResolvedTargets();
+    return true;
+  }
+
+  std::vector<LabelPattern> filters;
+  if (!commands::FilterPatternsFromString(build_settings, dir_filters, &filters,
+                                          err))
+    return false;
+
+  commands::FilterTargetsByPatterns(builder->GetAllResolvedTargets(), filters,
+                                    targets);
+
+  std::set<Label> labels;
+  std::queue<const Target*> to_process;
+  for (const Target* target : *targets) {
+    labels.insert(target->label());
+    to_process.push(target);
+  }
+
+  while (!to_process.empty()) {
+    const Target* target = to_process.front();
+    to_process.pop();
+    for (const auto& pair : target->GetDeps(Target::DEPS_ALL)) {
+      if (labels.find(pair.label) == labels.end()) {
+        targets->push_back(pair.ptr);
+        to_process.push(pair.ptr);
+        labels.insert(pair.label);
+      }
+    }
+  }
+
+  return true;
+}
+
 }  // namespace
 
 VisualStudioWriter::SolutionEntry::SolutionEntry(const std::string& _name,
                                                  const std::string& _path,
                                                  const std::string& _guid)
     : name(_name), path(_path), guid(_guid), parent_folder(nullptr) {}
 
 VisualStudioWriter::SolutionEntry::~SolutionEntry() = default;
 
 VisualStudioWriter::SolutionProject::SolutionProject(
@@ skipping 50 matching lines @@
 }
 
 // static
 bool VisualStudioWriter::RunAndWriteFiles(const BuildSettings* build_settings,
                                           Builder* builder,
                                           Version version,
                                           const std::string& sln_name,
                                           const std::string& dir_filters,
                                           Err* err) {
   std::vector<const Target*> targets;
-  if (dir_filters.empty()) {
-    targets = builder->GetAllResolvedTargets();
-  } else {
-    std::vector<LabelPattern> filters;
-    if (!commands::FilterPatternsFromString(build_settings, dir_filters,
-                                            &filters, err)) {
-      return false;
-    }
-
-    commands::FilterTargetsByPatterns(builder->GetAllResolvedTargets(), filters,
-                                      &targets);
-  }
+  if (!FilterTargets(build_settings, builder, dir_filters, &targets, err))
+    return false;
 
   const char* config_platform = "Win32";
 
   // Assume the "target_cpu" variable does not change between different
   // toolchains.
   if (!targets.empty()) {
     const Scope* scope = targets.front()->settings()->base_config();
     const Value* target_cpu_value = scope->GetValue(variables::kTargetCpu);
     if (target_cpu_value != nullptr &&
         target_cpu_value->string_value() == "x64")
@@ skipping 542 matching lines @@
   }
 }
 
 std::string VisualStudioWriter::GetNinjaTarget(const Target* target) {
   std::ostringstream ninja_target_out;
   DCHECK(!target->dependency_output_file().value().empty());
   ninja_path_output_.WriteFile(ninja_target_out,
                                target->dependency_output_file());
   return ninja_target_out.str();
 }