Limit the set of Visual Studio projects generated by GN

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 <map>
 #include <set>
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/strings/string_split.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/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"
 
 #if defined(OS_WIN)
@@ skipping 177 matching lines @@
 
 VisualStudioWriter::~VisualStudioWriter() {
   STLDeleteContainerPointers(projects_.begin(), projects_.end());
   STLDeleteContainerPointers(folders_.begin(), folders_.end());
 }
 
 // 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 = builder->GetAllResolvedTargets();
+  std::vector<const Target*> targets;
+  if (dir_filters.empty()) {
+    targets = builder->GetAllResolvedTargets();
+  } else {
+    std::vector<std::string> tokens = base::SplitString(
+        dir_filters, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+    SourceDir root_dir =
+        SourceDirForCurrentDirectory(build_settings->root_path());
+
+    std::vector<LabelPattern> filters;
+    for (const std::string& token : tokens) {
+      LabelPattern pattern =
+          LabelPattern::GetPattern(root_dir, Value(nullptr, token), err);
+      if (err->has_error())
+        return false;
+      filters.push_back(pattern);
+    }
+
+    commands::FilterTargetsByPatterns(builder->GetAllResolvedTargets(), filters,
+                                      &targets);
+  }
 
   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 23 matching lines @@
   }
 
   // Sort projects so they appear always in the same order in solution file.
   // Otherwise solution file is rewritten and reloaded by Visual Studio.
   std::sort(writer.projects_.begin(), writer.projects_.end(),
             [](const SolutionEntry* a, const SolutionEntry* b) {
               return a->path < b->path;
             });
 
   writer.ResolveSolutionFolders();
-  return writer.WriteSolutionFile(err);
+  return writer.WriteSolutionFile(sln_name, err);
 }
 
 bool VisualStudioWriter::WriteProjectFiles(const Target* target, Err* err) {
   std::string project_name = target->label().name();
   const char* project_config_platform = config_platform_;
   if (!target->settings()->is_default()) {
     project_name += "_" + target->toolchain()->label().name();
     const Value* value =
         target->settings()->base_config()->GetValue(variables::kCurrentCpu);
     if (value != nullptr && value->string_value() == "x64")
@@ skipping 310 matching lines @@
           }
           cl_item->SubElement("Filter")->Text(filter_path);
         }
       }
     }
   }
 
   project.Text(files_out.str());
 }
 
-bool VisualStudioWriter::WriteSolutionFile(Err* err) {
+bool VisualStudioWriter::WriteSolutionFile(const std::string& sln_name,
+                                           Err* err) {
+  std::string name = sln_name.empty() ? "all" : sln_name;
   SourceFile sln_file = build_settings_->build_dir().ResolveRelativeFile(
-      Value(nullptr, "all.sln"), err);
+      Value(nullptr, name + ".sln"), err);
   if (sln_file.is_null())
     return false;
 
   base::FilePath sln_path = build_settings_->GetFullPath(sln_file);
 
   std::stringstream string_out;
   WriteSolutionFileContents(string_out, sln_path.DirName());
 
   // Only write the content to the file if it's different. That is
   // both a performance optimization and more importantly, prevents
@@ skipping 91 matching lines @@
         size_t common_prefix_len = 0;
         size_t max_common_length =
             std::min(root_folder_path_.size(), folder_path.size());
         size_t i;
         for (i = common_prefix_len; i < max_common_length; ++i) {
           if (IsSlash(root_folder_path_[i]) && IsSlash(folder_path[i]))
             common_prefix_len = i + 1;
           else if (root_folder_path_[i] != folder_path[i])
             break;
         }
-        if (i == max_common_length)
+        if (i == max_common_length &&
+            (i == folder_path.size() || IsSlash(folder_path[i])))
           common_prefix_len = max_common_length;
         if (common_prefix_len < root_folder_path_.size()) {
           if (IsSlash(root_folder_path_[common_prefix_len - 1]))
             --common_prefix_len;
           root_folder_path_ = root_folder_path_.substr(0, common_prefix_len);
         }
       }
     }
   }
 
@@ skipping 44 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();
 }