GN support for generating VS2013 project files

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 46 matching lines @@
   ~SourceFileWriter() = default;
 
   void operator()(std::ostream& out) const {
     path_output_.WriteFile(out, source_file_);
   }
 
   PathOutput& path_output_;
   const SourceFile& source_file_;
 };
 
-const char kToolsetVersion[] = "v140";                     // Visual Studio 2015
-const char kVisualStudioVersion[] = "14.0";                // Visual Studio 2015
+const char kToolsetVersionVs2013[] = "v120";               // Visual Studio 2013
+const char kToolsetVersionVs2015[] = "v140";               // Visual Studio 2015
+const char kProjectVersionVs2013[] = "12.0";               // Visual Studio 2013
+const char kProjectVersionVs2015[] = "14.0";               // Visual Studio 2015
+const char kVersionStringVs2013[] = "Visual Studio 2013";  // Visual Studio 2013
+const char kVersionStringVs2015[] = "Visual Studio 2015";  // Visual Studio 2015
 const char kWindowsKitsVersion[] = "10";                   // Windows 10 SDK
 const char kWindowsKitsIncludeVersion[] = "10.0.10240.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";
 
 std::string GetWindowsKitsIncludeDirs() {
@@ skipping 87 matching lines @@
     const std::string& _path,
     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)
+VisualStudioWriter::VisualStudioWriter(const BuildSettings* build_settings,
+                                       Version version)
     : build_settings_(build_settings) {
   const Value* value = build_settings->build_args().GetArgOverride("is_debug");
   is_debug_config_ = value == nullptr || value->boolean_value();
   config_platform_ = "Win32";
   value = build_settings->build_args().GetArgOverride(variables::kTargetCpu);
   if (value != nullptr && value->string_value() == "x64")
     config_platform_ = "x64";
 
+  switch (version) {
+    case Version::Vs2013:
+      project_version_ = kProjectVersionVs2013;
+      toolset_version_ = kToolsetVersionVs2013;
+      version_string_ = kVersionStringVs2013;
+      break;
+    case Version::Vs2015:
+      project_version_ = kProjectVersionVs2015;
+      toolset_version_ = kToolsetVersionVs2015;
+      version_string_ = kVersionStringVs2015;
+      break;
+    default:
+      NOTREACHED() << "Not a valid Visual Studio Version: " << version;
+  }
+
   windows_kits_include_dirs_ = GetWindowsKitsIncludeDirs();
 }
 
 VisualStudioWriter::~VisualStudioWriter() {
   STLDeleteContainerPointers(projects_.begin(), projects_.end());
   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();
 
-  VisualStudioWriter writer(build_settings);
+  VisualStudioWriter writer(build_settings, 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 73 matching lines @@
     const Target* target,
     Err* err) {
   PathOutput path_output(GetTargetOutputDir(target),
                          build_settings_->root_path_utf8(),
                          EscapingMode::ESCAPE_NONE);
 
   out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
   XmlElementWriter project(
       out, "Project",
       XmlAttributes("DefaultTargets", "Build")
-          .add("ToolsVersion", kVisualStudioVersion)
+          .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));
@@ skipping 22 matching lines @@
     configuration->SubElement("CharacterSet")->Text("Unicode");
     std::string configuration_type = GetConfigurationType(target, err);
     if (configuration_type.empty())
       return false;
     configuration->SubElement("ConfigurationType")->Text(configuration_type);
   }
 
   {
     scoped_ptr<XmlElementWriter> locals =
         project.SubElement("PropertyGroup", XmlAttributes("Label", "Locals"));
-    locals->SubElement("PlatformToolset")->Text(kToolsetVersion);
+    locals->SubElement("PlatformToolset")->Text(toolset_version_);
   }
 
   project.SubElement(
       "Import",
       XmlAttributes("Project", "$(VCTargetsPath)\\Microsoft.Cpp.props"));
   project.SubElement(
       "Import",
       XmlAttributes("Project",
                     "$(VCTargetsPath)\\BuildCustomizations\\masm.props"));
   project.SubElement("ImportGroup",
@@ skipping 226 matching lines @@
   // both a performance optimization and more importantly, prevents
   // Visual Studio from reloading the projects.
   return WriteFileIfChanged(sln_path, string_out.str(), err);
 }
 
 void VisualStudioWriter::WriteSolutionFileContents(
     std::ostream& out,
     const base::FilePath& solution_dir_path) {
   out << "Microsoft Visual Studio Solution File, Format Version 12.00"
       << std::endl;
-  out << "# Visual Studio 2015" << std::endl;
+  out << "# " << version_string_ << std::endl;
 
   SourceDir solution_dir(FilePathToUTF8(solution_dir_path));
   for (const SolutionEntry* folder : folders_) {
     out << "Project(\"" << kGuidTypeFolder << "\") = \"(" << folder->name
         << ")\", \"" << RebasePath(folder->path, solution_dir, "/") << "\", \""
         << folder->guid << "\"" << std::endl;
     out << "EndProject" << std::endl;
   }
 
   for (const SolutionEntry* project : projects_) {
@@ skipping 129 matching lines @@
                            base::CompareCase::SENSITIVE)) {
         folder->parent_folder = parents.back();
         break;
       } else {
         parents.pop_back();
       }
     }
     parents.push_back(folder);
   }
 }