GN: Use std::unique_ptr for owned pointers in VisualStudioWriter.

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 <set>
 #include <string>
 
 #include "base/logging.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"
@@ skipping 186 matching lines @@
       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,
                                           const std::string& sln_name,
                                           const std::string& dir_filters,
                                           Err* err) {
   std::vector<const Target*> targets;
@@ skipping 48 matching lines @@
   }
 
   if (writer.projects_.empty()) {
     *err = Err(Location(), "No Visual Studio projects generated.");
     return false;
   }
 
   // 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) {
+            [](const std::unique_ptr<SolutionProject>& a,
+               const std::unique_ptr<SolutionProject>& b) {
               return a->path < b->path;
             });
 
   writer.ResolveSolutionFolders();
   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")
       project_config_platform = "x64";
     else
       project_config_platform = "Win32";
   }
 
   SourceFile target_file = GetTargetOutputDir(target).ResolveRelativeFile(
       Value(nullptr, project_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 SolutionProject(
+  projects_.emplace_back(new SolutionProject(
       project_name, vcxproj_path_str,
       MakeGuid(vcxproj_path_str, kGuidSeedProject),
       FilePathToUTF8(build_settings_->GetFullPath(target->label().dir())),
       project_config_platform));
 
   std::stringstream vcxproj_string_out;
   if (!WriteProjectFileContents(vcxproj_string_out, *projects_.back(), target,
                                 err)) {
     projects_.pop_back();
     return false;
@@ skipping 317 matching lines @@
 }
 
 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 << "# " << version_string_ << std::endl;
 
   SourceDir solution_dir(FilePathToUTF8(solution_dir_path));
-  for (const SolutionEntry* folder : folders_) {
+  for (const std::unique_ptr<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_) {
+  for (const std::unique_ptr<SolutionProject>& 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_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_) {
+  for (const std::unique_ptr<SolutionProject>& project : projects_) {
     const std::string project_config_mode =
         config_mode_prefix + project->config_platform;
     out << "\t\t" << project->guid << '.' << config_mode
         << ".ActiveCfg = " << project_config_mode << std::endl;
     out << "\t\t" << project->guid << '.' << config_mode
         << ".Build.0 = " << project_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_) {
+  for (const std::unique_ptr<SolutionEntry>& folder : folders_) {
     if (folder->parent_folder) {
       out << "\t\t" << folder->guid << " = " << folder->parent_folder->guid
           << std::endl;
     }
   }
-  for (const SolutionEntry* project : projects_) {
+  for (const std::unique_ptr<SolutionProject>& 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 (SolutionProject* project : projects_) {
+  for (const std::unique_ptr<SolutionProject>& 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(
+      std::unique_ptr<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;
+          folder_path_str, MakeGuid(folder_path_str, kGuidSeedFolder)));
+      project->parent_folder = folder.get();
+      processed_paths[folder_path] = folder.get();
+      folders_.push_back(std::move(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 &&
             (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);
         }
       }
     }
   }
 
   // Create also all parent folders up to |root_folder_path_|.
   SolutionFolders additional_folders;
-  for (SolutionEntry* folder : folders_) {
-    if (folder->path == root_folder_path_)
+  for (const std::unique_ptr<SolutionEntry>& solution_folder : folders_) {
+    if (solution_folder->path == root_folder_path_)
       continue;
 
+    SolutionEntry* folder = solution_folder.get();
     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(
+        std::unique_ptr<SolutionEntry> new_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;
+            MakeGuid(parent_path.as_string(), kGuidSeedFolder)));
+        processed_paths[parent_path] = new_folder.get();
+        folder = new_folder.get();
+        additional_folders.push_back(std::move(new_folder));
       }
     }
   }
-  folders_.insert(folders_.end(), additional_folders.begin(),
-                  additional_folders.end());
+  folders_.insert(folders_.end(),
+                  std::make_move_iterator(additional_folders.begin()),
+                  std::make_move_iterator(additional_folders.end()));
 
   // Sort folders by path.
   std::sort(folders_.begin(), folders_.end(),
-            [](const SolutionEntry* a, const SolutionEntry* b) {
+            [](const std::unique_ptr<SolutionEntry>& a,
+               const std::unique_ptr<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.
-  SolutionFolders parents;
-  for (SolutionEntry* folder : folders_) {
+  std::vector<SolutionEntry*> parents;
+  for (const std::unique_ptr<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);
+    parents.push_back(folder.get());
   }
 }
 
 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();
 }