Convert //tools to use std::unique_ptr

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 <memory>
 #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"
@@ skipping 321 matching lines @@
                          EscapingMode::ESCAPE_NONE);
 
   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(
+    std::unique_ptr<XmlElementWriter> configurations = project.SubElement(
         "ItemGroup", XmlAttributes("Label", "ProjectConfigurations"));
-    scoped_ptr<XmlElementWriter> project_config = configurations->SubElement(
-        "ProjectConfiguration",
-        XmlAttributes("Include", std::string(kConfigurationName) + '|' +
-                                     solution_project.config_platform));
+    std::unique_ptr<XmlElementWriter> project_config =
+        configurations->SubElement(
+            "ProjectConfiguration",
+            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 =
+    std::unique_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(
+    std::unique_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 =
+    std::unique_ptr<XmlElementWriter> locals =
         project.SubElement("PropertyGroup", XmlAttributes("Label", "Locals"));
     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",
                      XmlAttributes("Label", "ExtensionSettings"));
 
   {
-    scoped_ptr<XmlElementWriter> property_sheets = project.SubElement(
+    std::unique_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 =
+    std::unique_ptr<XmlElementWriter> properties =
         project.SubElement("PropertyGroup");
     {
-      scoped_ptr<XmlElementWriter> out_dir = properties->SubElement("OutDir");
+      std::unique_ptr<XmlElementWriter> out_dir =
+          properties->SubElement("OutDir");
       path_output.WriteDir(out_dir->StartContent(false),
                            build_settings_->build_dir(),
                            PathOutput::DIR_NO_LAST_SLASH);
     }
     properties->SubElement("TargetName")->Text("$(ProjectName)");
     if (target->output_type() != Target::GROUP) {
       properties->SubElement("TargetPath")
           ->Text("$(OutDir)\\$(ProjectName)$(TargetExt)");
     }
   }
 
   {
-    scoped_ptr<XmlElementWriter> item_definitions =
+    std::unique_ptr<XmlElementWriter> item_definitions =
         project.SubElement("ItemDefinitionGroup");
     {
-      scoped_ptr<XmlElementWriter> cl_compile =
+      std::unique_ptr<XmlElementWriter> cl_compile =
           item_definitions->SubElement("ClCompile");
       {
-        scoped_ptr<XmlElementWriter> include_dirs =
+        std::unique_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);
@@ skipping 21 matching lines @@
       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 =
+        std::unique_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");
+    std::unique_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");
     }
 
@@ skipping 11 matching lines @@
       XmlAttributes("Project", "$(VCTargetsPath)\\Microsoft.Cpp.targets"));
   project.SubElement(
       "Import",
       XmlAttributes("Project",
                     "$(VCTargetsPath)\\BuildCustomizations\\masm.targets"));
   project.SubElement("ImportGroup", XmlAttributes("Label", "ExtensionTargets"));
 
   std::string ninja_target = GetNinjaTarget(target);
 
   {
-    scoped_ptr<XmlElementWriter> build =
+    std::unique_ptr<XmlElementWriter> build =
         project.SubElement("Target", XmlAttributes("Name", "Build"));
     build->SubElement(
         "Exec", XmlAttributes("Command",
                               "call ninja.exe -C $(OutDir) " + ninja_target));
   }
 
   {
-    scoped_ptr<XmlElementWriter> clean =
+    std::unique_ptr<XmlElementWriter> clean =
         project.SubElement("Target", XmlAttributes("Name", "Clean"));
     clean->SubElement(
         "Exec",
         XmlAttributes("Command",
                       "call ninja.exe -C $(OutDir) -tclean " + ninja_target));
   }
 
   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 =
+    std::unique_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(
+        std::unique_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()) {
@@ skipping 194 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();
 }