GN: Visual Studio generator does not depend on is_debug variable

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>
@@ skipping 61 matching lines @@
 const char kVersionStringVs2015[] = "Visual Studio 2015";  // Visual Studio 2015
 const char kWindowsKitsVersion[] = "10";                   // Windows 10 SDK
 const char kWindowsKitsIncludeVersion[] = "10.0.10586.0";  // Windows 10 SDK
 
 const char kGuidTypeProject[] = "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}";
 const char kGuidTypeFolder[] = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}";
 const char kGuidSeedProject[] = "project";
 const char kGuidSeedFolder[] = "folder";
 const char kGuidSeedFilter[] = "filter";
 
+const char kConfigurationName[] = "GN";
+
 std::string GetWindowsKitsIncludeDirs() {
   std::string kits_path;
 
 #if defined(OS_WIN)
   const base::char16* const subkeys[] = {
       L"SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
       L"SOFTWARE\\Wow6432Node\\Microsoft\\Windows Kits\\Installed Roots"};
 
   base::string16 value_name =
       base::ASCIIToUTF16("KitsRoot") + base::ASCIIToUTF16(kWindowsKitsVersion);
@@ skipping 79 matching lines @@
     const std::string& _guid,
     const std::string& _label_dir_path,
     const std::string& _config_platform)
     : SolutionEntry(_name, _path, _guid),
       label_dir_path(_label_dir_path),
       config_platform(_config_platform) {}
 
 VisualStudioWriter::SolutionProject::~SolutionProject() = default;
 
 VisualStudioWriter::VisualStudioWriter(const BuildSettings* build_settings,
-                                       bool is_debug_config,
                                        const char* config_platform,
                                        Version version)
     : build_settings_(build_settings),
-      is_debug_config_(is_debug_config),
       config_platform_(config_platform),
       ninja_path_output_(build_settings->build_dir(),
                          build_settings->root_path_utf8(),
                          EscapingMode::ESCAPE_NINJA_COMMAND) {
   switch (version) {
     case Version::Vs2013:
       project_version_ = kProjectVersionVs2013;
       toolset_version_ = kToolsetVersionVs2013;
       version_string_ = kVersionStringVs2013;
       break;
@@ skipping 14 matching lines @@
   STLDeleteContainerPointers(folders_.begin(), folders_.end());
 }
 
 // static
 bool VisualStudioWriter::RunAndWriteFiles(const BuildSettings* build_settings,
                                           Builder* builder,
                                           Version version,
                                           Err* err) {
   std::vector<const Target*> targets = builder->GetAllResolvedTargets();
 
-  bool is_debug_config = true;
   const char* config_platform = "Win32";
 
-  // Assume the "is_debug" and "target_cpu" variables do not change
-  // between different toolchains.
+  // Assume the "target_cpu" variable does not change between different
+  // toolchains.
   if (!targets.empty()) {
     const Scope* scope = targets.front()->settings()->base_config();
-    const Value* is_debug_value = scope->GetValue("is_debug");
-    is_debug_config =
-        is_debug_value == nullptr || is_debug_value->boolean_value();
     const Value* target_cpu_value = scope->GetValue(variables::kTargetCpu);
     if (target_cpu_value != nullptr &&
         target_cpu_value->string_value() == "x64")
       config_platform = "x64";
   }
 
-  VisualStudioWriter writer(build_settings, is_debug_config, config_platform,
-                            version);
+  VisualStudioWriter writer(build_settings, config_platform, version);
   writer.projects_.reserve(targets.size());
   writer.folders_.reserve(targets.size());
 
   for (const Target* target : targets) {
     // Skip actions and groups.
     if (target->output_type() == Target::GROUP ||
         target->output_type() == Target::COPY_FILES ||
         target->output_type() == Target::ACTION ||
         target->output_type() == Target::ACTION_FOREACH) {
       continue;
@@ skipping 77 matching lines @@
   out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
   XmlElementWriter project(
       out, "Project",
       XmlAttributes("DefaultTargets", "Build")
           .add("ToolsVersion", project_version_)
           .add("xmlns", "http://schemas.microsoft.com/developer/msbuild/2003"));
 
   {
     scoped_ptr<XmlElementWriter> configurations = project.SubElement(
         "ItemGroup", XmlAttributes("Label", "ProjectConfigurations"));
-    std::string config_name = is_debug_config_ ? "Debug" : "Release";
     scoped_ptr<XmlElementWriter> project_config = configurations->SubElement(
         "ProjectConfiguration",
-        XmlAttributes("Include",
-                      config_name + '|' + solution_project.config_platform));
-    project_config->SubElement("Configuration")->Text(config_name);
+        XmlAttributes("Include", std::string(kConfigurationName) + '|' +
+                                     solution_project.config_platform));
+    project_config->SubElement("Configuration")->Text(kConfigurationName);
     project_config->SubElement("Platform")
         ->Text(solution_project.config_platform);
   }
 
   {
     scoped_ptr<XmlElementWriter> globals =
         project.SubElement("PropertyGroup", XmlAttributes("Label", "Globals"));
     globals->SubElement("ProjectGuid")->Text(solution_project.guid);
     globals->SubElement("Keyword")->Text("Win32Proj");
     globals->SubElement("RootNamespace")->Text(target->label().name());
@@ skipping 281 matching lines @@
     out << "Project(\"" << kGuidTypeProject << "\") = \"" << project->name
         << "\", \"" << RebasePath(project->path, solution_dir) << "\", \""
         << project->guid << "\"" << std::endl;
     out << "EndProject" << std::endl;
   }
 
   out << "Global" << std::endl;
 
   out << "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution"
       << std::endl;
-  const std::string config_mode_prefix =
-      std::string(is_debug_config_ ? "Debug" : "Release") + '|';
+  const std::string config_mode_prefix = std::string(kConfigurationName) + '|';
   const std::string config_mode = config_mode_prefix + config_platform_;
   out << "\t\t" << config_mode << " = " << config_mode << std::endl;
   out << "\tEndGlobalSection" << std::endl;
 
   out << "\tGlobalSection(ProjectConfigurationPlatforms) = postSolution"
       << std::endl;
   for (const SolutionProject* project : projects_) {
     const std::string project_config_mode =
         config_mode_prefix + project->config_platform;
     out << "\t\t" << project->guid << '.' << config_mode
@@ skipping 115 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();
 }