Visual Studio generators for 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/files/file_util.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "tools/gn/builder.h"
+#include "tools/gn/config.h"
+#include "tools/gn/config_values_extractors.h"
+#include "tools/gn/filesystem_utils.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)
+#include "base/win/registry.h"
+#endif
+
+namespace {
+
+struct SemicolonSeparatedWriter {
+  void operator()(const std::string& value, std::ostream& out) const {
+    out << value + ';';
+  }
+};
+
+struct IncludeDirWriter {
+  explicit IncludeDirWriter(PathOutput& path_output)
+      : path_output_(path_output) {}
+  ~IncludeDirWriter() = default;
+
+  void operator()(const SourceDir& dir, std::ostream& out) const {
+    path_output_.WriteDir(out, dir, PathOutput::DIR_NO_LAST_SLASH);
+    out << ";";
+  }
+
+  PathOutput& path_output_;
+};
+
+struct SourceFileWriter {
+  SourceFileWriter(PathOutput& path_output, const SourceFile& source_file)
+      : path_output_(path_output), source_file_(source_file) {}
+  ~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 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() {
+  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);
+
+  for (const base::char16* subkey : subkeys) {
+    base::win::RegKey key(HKEY_LOCAL_MACHINE, subkey, KEY_READ);
+    base::string16 value;
+    if (key.ReadValue(value_name.c_str(), &value) == ERROR_SUCCESS) {
+      kits_path = base::UTF16ToUTF8(value);
+      break;
+    }
+  }
+#endif  // OS_WIN
+
+  if (kits_path.empty()) {
+    kits_path = std::string("C:\\Program Files (x86)\\Windows Kits\\") +
+                kWindowsKitsVersion + "\\";
+  }
+
+  return kits_path + "Include\\" + kWindowsKitsIncludeVersion + "\\shared;" +
+         kits_path + "Include\\" + kWindowsKitsIncludeVersion + "\\um;" +
+         kits_path + "Include\\" + kWindowsKitsIncludeVersion + "\\winrt;";
+}
+
+std::string GetConfigurationType(const Target* target, Err* err) {
+  switch (target->output_type()) {
+    case Target::EXECUTABLE:
+      return "Application";
+    case Target::SHARED_LIBRARY:
+    case Target::LOADABLE_MODULE:
+      return "DynamicLibrary";
+    case Target::STATIC_LIBRARY:
+    case Target::SOURCE_SET:
+      return "StaticLibrary";
+
+    default:
+      *err = Err(Location(),
+                 "Visual Studio doesn't support '" + target->label().name() +
+                     "' target output type: " +
+                     Target::GetStringForOutputType(target->output_type()));
+      return std::string();
+  }
+}
+
+void ParseCompilerOptions(const std::vector<std::string>& cflags,
+                          CompilerOptions* options) {
+  for (const std::string& flag : cflags)
+    ParseCompilerOption(flag, options);
+}
+
+void ParseCompilerOptions(const Target* target, CompilerOptions* options) {
+  for (ConfigValuesIterator iter(target); !iter.done(); iter.Next()) {
+    ParseCompilerOptions(iter.cur().cflags(), options);
+    ParseCompilerOptions(iter.cur().cflags_c(), options);
+    ParseCompilerOptions(iter.cur().cflags_cc(), options);
+  }
+}
+
+// Returns a string piece pointing into the input string identifying the parent
+// directory path, excluding the last slash. Note that the input pointer must
+// 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 HasSameContent(std::stringstream& data_1, const base::FilePath& data_2) {
+  // Compare file sizes first. Quick and will save us some time if they are
+  // different sizes.
+  int64_t data_1_len = data_1.tellp();
+
+  int64_t data_2_len;
+  if (!base::GetFileSize(data_2, &data_2_len) || data_1_len != data_2_len)
+    return false;
+
+  std::string data_2_data;
+  data_2_data.resize(data_2_len);
+  if (!base::ReadFileToString(data_2, &data_2_data))
+    return false;
+
+  std::string data_1_data;
+  data_1_data = data_1.str();
+
+  return data_1_data == data_2_data;
+}
+
+}  // 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::VisualStudioWriter(const BuildSettings* build_settings)
+    : 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";
+
+  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,
+                                          Err* err) {
+  std::vector<const Target*> targets = builder->GetAllResolvedTargets();
+
+  VisualStudioWriter writer(build_settings);
+  writer.projects_.reserve(targets.size());
+  writer.folders_.reserve(targets.size());
+
+  std::set<std::string> processed_targets;
+  for (const Target* target : targets) {
+    // Skip targets which are duplicated in vector.
+    std::string target_path =
+        target->label().dir().value() + target->label().name();
+    if (processed_targets.find(target_path) != processed_targets.end())
+      continue;
+
+    // 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;
+    }
+
+    if (!writer.WriteProjectFiles(target, err))
+      return false;
+
+    processed_targets.insert(target_path);
+  }
+
+  if (writer.projects_.empty()) {
+    *err = Err(Location(), "No Visual Studio projects generated.");
+    return false;
+  }
+
+  writer.ResolveSolutionFolders();
+  return writer.WriteSolutionFile(err);
+}
+
+bool VisualStudioWriter::WriteProjectFiles(const Target* target, Err* err) {
+  SourceFile target_file = GetTargetOutputDir(target).ResolveRelativeFile(
+      Value(nullptr, target->label().name() + ".vcxproj"), err);
+  if (target_file.is_null())
+    return false;
+
+  base::FilePath vcxproj_path = build_settings_->GetFullPath(target_file);
+  std::string vcxproj_path_str = FilePathToUTF8(vcxproj_path);
+
+  projects_.push_back(
+      new SolutionEntry(target->label().name(), vcxproj_path_str,
+                        MakeGuid(vcxproj_path_str, kGuidSeedProject)));
+  projects_.back()->label_dir_path =
+      FilePathToUTF8(build_settings_->GetFullPath(target->label().dir()));
+
+  std::stringstream vcxproj_string_out;
+  if (!WriteProjectFileContents(vcxproj_string_out, *projects_.back(), target,
+                                err)) {
+    projects_.pop_back();
+    return false;
+  }
+
+  // Only write the content to the file if it's different. That is
+  // both a performance optimization and more importantly, prevents
+  // Visual Studio from reloading the projects.
+  if (!HasSameContent(vcxproj_string_out, vcxproj_path)) {
+    std::string content = vcxproj_string_out.str();
+    int size = static_cast<int>(content.size());
+    if (base::WriteFile(vcxproj_path, content.c_str(), size) != size) {
+      *err = Err(Location(), "Couldn't open " + target->label().name() +
+                                 ".vcxproj for writing");
+      return false;
+    }
+  }
+
+  base::FilePath filters_path = UTF8ToFilePath(vcxproj_path_str + ".filters");
+
+  std::stringstream filters_string_out;
+  WriteFiltersFileContents(filters_string_out, target);
+
+  if (!HasSameContent(filters_string_out, filters_path)) {
+    std::string content = filters_string_out.str();
+    int size = static_cast<int>(content.size());
+    if (base::WriteFile(filters_path, content.c_str(), size) != size) {
+      *err = Err(Location(), "Couldn't open " + target->label().name() +
+                                 ".vcxproj.filters for writing");
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool VisualStudioWriter::WriteProjectFileContents(
+    std::ostream& out,
+    const SolutionEntry& solution_project,
+    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("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 + '|' + config_platform_));
+    project_config->SubElement("Configuration")->Text(config_name);
+    project_config->SubElement("Platform")->Text(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());
+    globals->SubElement("IgnoreWarnCompileDuplicatedFilename")->Text("true");
+    globals->SubElement("PreferredToolArchitecture")->Text("x64");
+  }
+
+  project.SubElement(
+      "Import", XmlAttributes("Project",
+                              "$(VCTargetsPath)\\Microsoft.Cpp.Default.props"));
+
+  {
+    scoped_ptr<XmlElementWriter> configuration = project.SubElement(
+        "PropertyGroup", XmlAttributes("Label", "Configuration"));
+    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);
+  }
+
+  project.SubElement(
+      "Import",
+      XmlAttributes("Project", "$(VCTargetsPath)\\Microsoft.Cpp.props"));
+  project.SubElement(
+      "Import",
+      XmlAttributes("Project",
+                    "$(VCTargetsPath)\\BuildCustomizations\\masm.props"));
+  project.SubElement("ImportGroup",
+                     XmlAttributes("Label", "ExtensionSettings"));
+
+  {
+    scoped_ptr<XmlElementWriter> property_sheets = project.SubElement(
+        "ImportGroup", XmlAttributes("Label", "PropertySheets"));
+    property_sheets->SubElement(
+        "Import",
+        XmlAttributes(
+            "Condition",
+            "exists('$(UserRootDir)\\Microsoft.Cpp.$(Platform).user.props')")
+            .add("Label", "LocalAppDataPlatform")
+            .add("Project",
+                 "$(UserRootDir)\\Microsoft.Cpp.$(Platform).user.props"));
+  }
+
+  project.SubElement("PropertyGroup", XmlAttributes("Label", "UserMacros"));
+
+  {
+    scoped_ptr<XmlElementWriter> properties =
+        project.SubElement("PropertyGroup");
+    {
+      scoped_ptr<XmlElementWriter> out_dir = properties->SubElement("OutDir");
+      path_output.WriteDir(out_dir->StartContent(false),
+                           build_settings_->build_dir(),
+                           PathOutput::DIR_INCLUDE_LAST_SLASH);
+    }
+    properties->SubElement("TargetName")->Text("$(ProjectName)");
+    properties->SubElement("TargetPath")
+        ->Text("$(OutDir)\\$(ProjectName)$(TargetExt)");
+  }
+
+  {
+    scoped_ptr<XmlElementWriter> item_definitions =
+        project.SubElement("ItemDefinitionGroup");
+    {
+      scoped_ptr<XmlElementWriter> cl_compile =
+          item_definitions->SubElement("ClCompile");
+      {
+        scoped_ptr<XmlElementWriter> include_dirs =
+            cl_compile->SubElement("AdditionalIncludeDirectories");
+        RecursiveTargetConfigToStream<SourceDir>(
+            target, &ConfigValues::include_dirs, IncludeDirWriter(path_output),
+            include_dirs->StartContent(false));
+        include_dirs->Text(windows_kits_include_dirs_ +
+                           "$(VSInstallDir)\\VC\\atlmfc\\include;" +
+                           "%(AdditionalIncludeDirectories)");
+      }
+      CompilerOptions options;
+      ParseCompilerOptions(target, &options);
+      if (!options.additional_options.empty()) {
+        cl_compile->SubElement("AdditionalOptions")
+            ->Text(options.additional_options + "%(AdditionalOptions)");
+      }
+      if (!options.buffer_security_check.empty()) {
+        cl_compile->SubElement("BufferSecurityCheck")
+            ->Text(options.buffer_security_check);
+      }
+      cl_compile->SubElement("CompileAsWinRT")->Text("false");
+      cl_compile->SubElement("DebugInformationFormat")->Text("ProgramDatabase");
+      if (!options.disable_specific_warnings.empty()) {
+        cl_compile->SubElement("DisableSpecificWarnings")
+            ->Text(options.disable_specific_warnings +
+                   "%(DisableSpecificWarnings)");
+      }
+      cl_compile->SubElement("ExceptionHandling")->Text("false");
+      if (!options.forced_include_files.empty()) {
+        cl_compile->SubElement("ForcedIncludeFiles")
+            ->Text(options.forced_include_files);
+      }
+      cl_compile->SubElement("MinimalRebuild")->Text("false");
+      if (!options.optimization.empty())
+        cl_compile->SubElement("Optimization")->Text(options.optimization);
+      if (target->config_values().has_precompiled_headers()) {
+        cl_compile->SubElement("PrecompiledHeader")->Text("Use");
+        cl_compile->SubElement("PrecompiledHeaderFile")
+            ->Text(target->config_values().precompiled_header());
+      } else {
+        cl_compile->SubElement("PrecompiledHeader")->Text("NotUsing");
+      }
+      {
+        scoped_ptr<XmlElementWriter> preprocessor_definitions =
+            cl_compile->SubElement("PreprocessorDefinitions");
+        RecursiveTargetConfigToStream<std::string>(
+            target, &ConfigValues::defines, SemicolonSeparatedWriter(),
+            preprocessor_definitions->StartContent(false));
+        preprocessor_definitions->Text("%(PreprocessorDefinitions)");
+      }
+      if (!options.runtime_library.empty())
+        cl_compile->SubElement("RuntimeLibrary")->Text(options.runtime_library);
+      if (!options.treat_warning_as_error.empty()) {
+        cl_compile->SubElement("TreatWarningAsError")
+            ->Text(options.treat_warning_as_error);
+      }
+      if (!options.warning_level.empty())
+        cl_compile->SubElement("WarningLevel")->Text(options.warning_level);
+    }
+
+    // We don't include resource compilation and link options as ninja files
+    // are used to generate real build.
+  }
+
+  {
+    scoped_ptr<XmlElementWriter> group = project.SubElement("ItemGroup");
+    if (!target->config_values().precompiled_source().is_null()) {
+      group
+          ->SubElement(
+              "ClCompile", "Include",
+              SourceFileWriter(path_output,
+                               target->config_values().precompiled_source()))
+          ->SubElement("PrecompiledHeader")
+          ->Text("Create");
+    }
+
+    for (const SourceFile& file : target->sources()) {
+      SourceFileType type = GetSourceFileType(file);
+      if (type == SOURCE_H || type == SOURCE_CPP || type == SOURCE_C) {
+        group->SubElement(type == SOURCE_H ? "ClInclude" : "ClCompile",
+                          "Include", SourceFileWriter(path_output, file));
+      }
+    }
+  }
+
+  project.SubElement(
+      "Import",
+      XmlAttributes("Project", "$(VCTargetsPath)\\Microsoft.Cpp.targets"));
+  project.SubElement(
+      "Import",
+      XmlAttributes("Project",
+                    "$(VCTargetsPath)\\BuildCustomizations\\masm.targets"));
+  project.SubElement("ImportGroup", XmlAttributes("Label", "ExtensionTargets"));
+
+  {
+    scoped_ptr<XmlElementWriter> build =
+        project.SubElement("Target", XmlAttributes("Name", "Build"));
+    build->SubElement(
+        "Exec",
+        XmlAttributes("Command", "call ninja.exe -C $(OutDir) $(ProjectName)"));
+  }
+
+  {
+    scoped_ptr<XmlElementWriter> clean =
+        project.SubElement("Target", XmlAttributes("Name", "Clean"));
+    clean->SubElement(
+        "Exec",
+        XmlAttributes("Command",
+                      "call ninja.exe -C $(OutDir) -tclean $(ProjectName)"));
+  }
+
+  return true;
+}
+
+void VisualStudioWriter::WriteFiltersFileContents(std::ostream& out,
+                                                  const Target* target) {
+  out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
+  XmlElementWriter project(
+      out, "Project",
+      XmlAttributes("ToolsVersion", "4.0")
+          .add("xmlns", "http://schemas.microsoft.com/developer/msbuild/2003"));
+
+  std::ostringstream files_out;
+
+  {
+    scoped_ptr<XmlElementWriter> filters_group =
+        project.SubElement("ItemGroup");
+    XmlElementWriter files_group(files_out, "ItemGroup", XmlAttributes(), 2);
+
+    // File paths are relative to vcxproj files which are generated to out dirs.
+    // Filters tree structure need to reflect source directories and be relative
+    // to target file. We need two path outputs then.
+    PathOutput file_path_output(GetTargetOutputDir(target),
+                                build_settings_->root_path_utf8(),
+                                EscapingMode::ESCAPE_NONE);
+    PathOutput filter_path_output(target->label().dir(),
+                                  build_settings_->root_path_utf8(),
+                                  EscapingMode::ESCAPE_NONE);
+
+    std::set<std::string> processed_filters;
+
+    for (const SourceFile& file : target->sources()) {
+      SourceFileType type = GetSourceFileType(file);
+      if (type == SOURCE_H || type == SOURCE_CPP || type == SOURCE_C) {
+        scoped_ptr<XmlElementWriter> cl_item = files_group.SubElement(
+            type == SOURCE_H ? "ClInclude" : "ClCompile", "Include",
+            SourceFileWriter(file_path_output, file));
+
+        std::ostringstream target_relative_out;
+        filter_path_output.WriteFile(target_relative_out, file);
+        std::string target_relative_path = target_relative_out.str();
+        ConvertPathToSystem(&target_relative_path);
+        base::StringPiece filter_path = FindParentDir(&target_relative_path);
+
+        if (!filter_path.empty()) {
+          std::string filter_path_str = filter_path.as_string();
+          while (processed_filters.find(filter_path_str) ==
+                 processed_filters.end()) {
+            auto it = processed_filters.insert(filter_path_str).first;
+            filters_group
+                ->SubElement("Filter",
+                             XmlAttributes("Include", filter_path_str))
+                ->SubElement("UniqueIdentifier")
+                ->Text(MakeGuid(filter_path_str, kGuidSeedFilter));
+            filter_path_str = FindParentDir(&(*it)).as_string();
+            if (filter_path_str.empty())
+              break;
+          }
+          cl_item->SubElement("Filter")->Text(filter_path);
+        }
+      }
+    }
+  }
+
+  project.Text(files_out.str());
+}
+
+bool VisualStudioWriter::WriteSolutionFile(Err* err) {
+  SourceFile sln_file = build_settings_->build_dir().ResolveRelativeFile(
+      Value(nullptr, "all.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
+  // Visual Studio from reloading the projects.
+  if (HasSameContent(string_out, sln_path))
+    return true;
+
+  std::string content = string_out.str();
+  int size = static_cast<int>(content.size());
+  if (base::WriteFile(sln_path, content.c_str(), size) != size) {
+    *err = Err(Location(), "Couldn't open all.sln for writing");
+    return false;
+  }
+
+  return true;
+}
+
+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;
+
+  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_) {
+    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 =
+      std::string(is_debug_config_ ? "Debug" : "Release") + '|' +
+      config_platform_;
+  out << "\t\t" << config_mode << " = " << config_mode << std::endl;
+  out << "\tEndGlobalSection" << std::endl;
+
+  out << "\tGlobalSection(ProjectConfigurationPlatforms) = postSolution"
+      << std::endl;
+  for (const SolutionEntry* project : projects_) {
+    out << "\t\t" << project->guid << '.' << config_mode
+        << ".ActiveCfg = " << config_mode << std::endl;
+    out << "\t\t" << project->guid << '.' << config_mode
+        << ".Build.0 = " << config_mode << std::endl;
+  }
+  out << "\tEndGlobalSection" << std::endl;
+
+  out << "\tGlobalSection(SolutionProperties) = preSolution" << std::endl;
+  out << "\t\tHideSolutionNode = FALSE" << std::endl;
+  out << "\tEndGlobalSection" << std::endl;
+
+  out << "\tGlobalSection(NestedProjects) = preSolution" << std::endl;
+  for (const SolutionEntry* folder : folders_) {
+    if (folder->parent_folder) {
+      out << "\t\t" << folder->guid << " = " << folder->parent_folder->guid
+          << std::endl;
+    }
+  }
+  for (const SolutionEntry* project : projects_) {
+    out << "\t\t" << project->guid << " = " << project->parent_folder->guid
+        << std::endl;
+  }
+  out << "\tEndGlobalSection" << std::endl;
+
+  out << "EndGlobal" << std::endl;
+}
+
+void VisualStudioWriter::ResolveSolutionFolders() {
+  root_folder_path_.clear();
+
+  // Get all project directories. Create solution folder for each directory.
+  std::map<base::StringPiece, SolutionEntry*> processed_paths;
+  for (SolutionEntry* project : projects_) {
+    base::StringPiece folder_path = project->label_dir_path;
+    if (IsSlash(folder_path[folder_path.size() - 1]))
+      folder_path = folder_path.substr(0, folder_path.size() - 1);
+    auto it = processed_paths.find(folder_path);
+    if (it != processed_paths.end()) {
+      project->parent_folder = it->second;
+    } else {
+      std::string folder_path_str = folder_path.as_string();
+      SolutionEntry* folder = new SolutionEntry(
+          FindLastDirComponent(SourceDir(folder_path)).as_string(),
+          folder_path_str, MakeGuid(folder_path_str, kGuidSeedFolder));
+      folders_.push_back(folder);
+      project->parent_folder = folder;
+      processed_paths[folder_path] = folder;
+
+      if (root_folder_path_.empty()) {
+        root_folder_path_ = folder_path_str;
+      } else {
+        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)
+          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);
+        }
+      }
+    }
+  }
+
+  // Create also all parent folders up to |root_folder_path_|.
+  SolutionEntries additional_folders;
+  for (SolutionEntry* folder : folders_) {
+    if (folder->path == root_folder_path_)
+      continue;
+
+    base::StringPiece parent_path;
+    while ((parent_path = FindParentDir(&folder->path)) != root_folder_path_) {
+      auto it = processed_paths.find(parent_path);
+      if (it != processed_paths.end()) {
+        folder = it->second;
+      } else {
+        folder = new SolutionEntry(
+            FindLastDirComponent(SourceDir(parent_path)).as_string(),
+            parent_path.as_string(),
+            MakeGuid(parent_path.as_string(), kGuidSeedFolder));
+        additional_folders.push_back(folder);
+        processed_paths[parent_path] = folder;
+      }
+    }
+  }
+  folders_.insert(folders_.end(), additional_folders.begin(),
+                  additional_folders.end());
+
+  // Sort folders by path.
+  std::sort(folders_.begin(), folders_.end(),
+            [](const SolutionEntry* a, const SolutionEntry* b) {
+              return a->path < b->path;
+            });
+
+  // Match subfolders with their parents. Since |folders_| are sorted by path we
+  // know that parent folder always precedes its children in vector.
+  SolutionEntries parents;
+  for (SolutionEntry* folder : folders_) {
+    while (!parents.empty()) {
+      if (base::StartsWith(folder->path, parents.back()->path,
+                           base::CompareCase::SENSITIVE)) {
+        folder->parent_folder = parents.back();
+        break;
+      } else {
+        parents.pop_back();
+      }
+    }
+    parents.push_back(folder);
+  }
+}