Re-write many calls to WrapUnique() with MakeUnique()

tools/gn/xcode_object.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/xcode_object.h"
 
 #include <iomanip>
 #include <sstream>
 #include <utility>
 
@@ skipping 299 matching lines @@
 // PBXTarget ------------------------------------------------------------------
 
 PBXTarget::PBXTarget(const std::string& name,
                      const std::string& shell_script,
                      const std::string& config_name,
                      const PBXAttributes& attributes)
     : configurations_(new XCConfigurationList(config_name, attributes, this)),
       name_(name) {
   if (!shell_script.empty()) {
     build_phases_.push_back(
-        base::WrapUnique(new PBXShellScriptBuildPhase(name, shell_script)));
+        base::MakeUnique<PBXShellScriptBuildPhase>(name, shell_script));
   }
 }
 
 PBXTarget::~PBXTarget() {}
 
 std::string PBXTarget::Name() const {
   return name_;
 }
 
 void PBXTarget::Visit(PBXObjectVisitor& visitor) {
@@ skipping 137 matching lines @@
 PBXObject* PBXGroup::AddChild(std::unique_ptr<PBXObject> child) {
   DCHECK(child);
   children_.push_back(std::move(child));
   return children_.back().get();
 }
 
 PBXFileReference* PBXGroup::AddSourceFile(const std::string& source_path) {
   DCHECK(!source_path.empty());
   std::string::size_type sep = source_path.find("/");
   if (sep == std::string::npos) {
-    children_.push_back(base::WrapUnique(
-        new PBXFileReference(std::string(), source_path, std::string())));
+    children_.push_back(base::MakeUnique<PBXFileReference>(
+        std::string(), source_path, std::string()));
     return static_cast<PBXFileReference*>(children_.back().get());
   }
 
   PBXGroup* group = nullptr;
   base::StringPiece component(source_path.data(), sep);
   for (const auto& child : children_) {
     if (child->Class() != PBXGroupClass)
       continue;
 
     PBXGroup* child_as_group = static_cast<PBXGroup*>(child.get());
@@ skipping 66 matching lines @@
 
   build_phases_.push_back(base::WrapUnique(new PBXFrameworksBuildPhase));
 }
 
 PBXNativeTarget::~PBXNativeTarget() {}
 
 void PBXNativeTarget::AddFileForIndexing(
     const PBXFileReference* file_reference) {
   DCHECK(file_reference);
   source_build_phase_->AddBuildFile(
-      base::WrapUnique(new PBXBuildFile(file_reference, source_build_phase_)));
+      base::MakeUnique<PBXBuildFile>(file_reference, source_build_phase_));
 }
 
 PBXObjectClass PBXNativeTarget::Class() const {
   return PBXNativeTargetClass;
 }
 
 void PBXNativeTarget::Print(std::ostream& out, unsigned indent) const {
   const std::string indent_str(indent, '\t');
   const IndentRules rules = {false, indent + 1};
   out << indent_str << Reference() << " = {\n";
@@ skipping 12 matching lines @@
 // PBXProject -----------------------------------------------------------------
 
 PBXProject::PBXProject(const std::string& name,
                        const std::string& config_name,
                        const std::string& source_path,
                        const PBXAttributes& attributes)
     : name_(name), config_name_(config_name), target_for_indexing_(nullptr) {
   attributes_["BuildIndependentTargetsInParallel"] = "YES";
 
   main_group_.reset(new PBXGroup);
-  sources_ = static_cast<PBXGroup*>(main_group_->AddChild(
-      base::WrapUnique(new PBXGroup(source_path, "Source"))));
+  sources_ = static_cast<PBXGroup*>(
+      main_group_->AddChild(base::MakeUnique<PBXGroup>(source_path, "Source")));
   products_ = static_cast<PBXGroup*>(main_group_->AddChild(
-      base::WrapUnique(new PBXGroup(std::string(), "Product"))));
-  main_group_->AddChild(base::WrapUnique(new PBXGroup(std::string(), "Build")));
+      base::MakeUnique<PBXGroup>(std::string(), "Product")));
+  main_group_->AddChild(base::MakeUnique<PBXGroup>(std::string(), "Build"));
 
   configurations_.reset(new XCConfigurationList(config_name, attributes, this));
 }
 
 PBXProject::~PBXProject() {}
 
 void PBXProject::AddSourceFile(const std::string& source_path) {
   PBXFileReference* file_reference = sources_->AddSourceFile(source_path);
   base::StringPiece ext = FindExtension(&source_path);
   if (!IsSourceFileForIndexing(ext))
     return;
 
   if (!target_for_indexing_) {
     PBXAttributes attributes;
     attributes["EXECUTABLE_PREFIX"] = "";
     attributes["HEADER_SEARCH_PATHS"] = sources_->path();
     attributes["PRODUCT_NAME"] = name_;
 
     PBXFileReference* product_reference = static_cast<PBXFileReference*>(
-        products_->AddChild(base::WrapUnique(new PBXFileReference(
-            std::string(), name_, "compiled.mach-o.executable"))));
+        products_->AddChild(base::MakeUnique<PBXFileReference>(
+            std::string(), name_, "compiled.mach-o.executable")));
 
     const char product_type[] = "com.apple.product-type.tool";
-    targets_.push_back(base::WrapUnique(
-        new PBXNativeTarget(name_, std::string(), config_name_, attributes,
-                            product_type, name_, product_reference)));
+    targets_.push_back(base::MakeUnique<PBXNativeTarget>(
+        name_, std::string(), config_name_, attributes, product_type, name_,
+        product_reference));
     target_for_indexing_ = static_cast<PBXNativeTarget*>(targets_.back().get());
   }
 
   DCHECK(target_for_indexing_);
   target_for_indexing_->AddFileForIndexing(file_reference);
 }
 
 void PBXProject::AddAggregateTarget(const std::string& name,
                                     const std::string& shell_script) {
   PBXAttributes attributes;
   attributes["CODE_SIGNING_REQUIRED"] = "NO";
   attributes["CONFIGURATION_BUILD_DIR"] = ".";
   attributes["PRODUCT_NAME"] = name;
 
-  targets_.push_back(base::WrapUnique(
-      new PBXAggregateTarget(name, shell_script, config_name_, attributes)));
+  targets_.push_back(base::MakeUnique<PBXAggregateTarget>(
+      name, shell_script, config_name_, attributes));
 }
 
 void PBXProject::AddNativeTarget(const std::string& name,
                                  const std::string& type,
                                  const std::string& output_name,
                                  const std::string& output_type,
                                  const std::string& shell_script) {
   base::StringPiece ext = FindExtension(&output_name);
-  PBXFileReference* product =
-      static_cast<PBXFileReference*>(products_->AddChild(base::WrapUnique(
-          new PBXFileReference(std::string(), output_name,
-                               type.empty() ? GetSourceType(ext) : type))));
+  PBXFileReference* product = static_cast<PBXFileReference*>(
+      products_->AddChild(base::MakeUnique<PBXFileReference>(
+          std::string(), output_name,
+          type.empty() ? GetSourceType(ext) : type)));
 
   size_t ext_offset = FindExtensionOffset(output_name);
   std::string product_name = ext_offset != std::string::npos
                                  ? output_name.substr(0, ext_offset - 1)
                                  : output_name;
 
   PBXAttributes attributes;
   attributes["CODE_SIGNING_REQUIRED"] = "NO";
   attributes["CONFIGURATION_BUILD_DIR"] = ".";
   attributes["PRODUCT_NAME"] = product_name;
 
-  targets_.push_back(base::WrapUnique(
-      new PBXNativeTarget(name, shell_script, config_name_, attributes,
-                          output_type, product_name, product)));
+  targets_.push_back(base::MakeUnique<PBXNativeTarget>(
+      name, shell_script, config_name_, attributes, output_type, product_name,
+      product));
 }
 
 void PBXProject::SetProjectDirPath(const std::string& project_dir_path) {
   DCHECK(!project_dir_path.empty());
   project_dir_path_.assign(project_dir_path);
 }
 
 void PBXProject::SetProjectRoot(const std::string& project_root) {
   DCHECK(!project_root.empty());
   project_root_.assign(project_root);
@@ skipping 142 matching lines @@
 }
 
 // XCConfigurationList --------------------------------------------------------
 
 XCConfigurationList::XCConfigurationList(const std::string& name,
                                          const PBXAttributes& attributes,
                                          const PBXObject* owner_reference)
     : owner_reference_(owner_reference) {
   DCHECK(owner_reference_);
   configurations_.push_back(
-      base::WrapUnique(new XCBuildConfiguration(name, attributes)));
+      base::MakeUnique<XCBuildConfiguration>(name, attributes));
 }
 
 XCConfigurationList::~XCConfigurationList() {}
 
 PBXObjectClass XCConfigurationList::Class() const {
   return XCConfigurationListClass;
 }
 
 std::string XCConfigurationList::Name() const {
   std::stringstream buffer;
@@ skipping 14 matching lines @@
   const std::string indent_str(indent, '\t');
   const IndentRules rules = {false, indent + 1};
   out << indent_str << Reference() << " = {\n";
   PrintProperty(out, rules, "isa", ToString(Class()));
   PrintProperty(out, rules, "buildConfigurations", configurations_);
   PrintProperty(out, rules, "defaultConfigurationIsVisible", 1u);
   PrintProperty(out, rules, "defaultConfigurationName",
                 configurations_[0]->Name());
   out << indent_str << "};\n";
 }