diff --git a/tools/gn/analyzer.cc b/tools/gn/analyzer.cc
index cc403c2..b69b4d8 100644
--- a/tools/gn/analyzer.cc
+++ b/tools/gn/analyzer.cc
@@ -6,12 +6,12 @@
 
 #include <algorithm>
 #include <iterator>
+#include <memory>
 #include <set>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "tools/gn/builder.h"
@@ -111,7 +111,7 @@
                  const std::string& key,
                  const LabelSet& labels) {
   std::vector<std::string> strings;
-  auto value = base::MakeUnique<base::ListValue>();
+  auto value = std::make_unique<base::ListValue>();
   for (const auto l : labels)
     strings.push_back(l.GetUserVisibleName(default_toolchain));
   std::sort(strings.begin(), strings.end());
@@ -197,7 +197,7 @@
 std::string OutputsToJSON(const Outputs& outputs,
                           const Label& default_toolchain, Err *err) {
   std::string output;
-  auto value = base::MakeUnique<base::DictionaryValue>();
+  auto value = std::make_unique<base::DictionaryValue>();
 
   if (outputs.error.size()) {
     WriteString(*value, "error", outputs.error);
@@ -206,7 +206,7 @@
   } else {
     WriteString(*value, "status", outputs.status);
     if (outputs.compile_includes_all) {
-      auto compile_targets = base::MakeUnique<base::ListValue>();
+      auto compile_targets = std::make_unique<base::ListValue>();
       compile_targets->AppendString("all");
       value->SetWithoutPathExpansion("compile_targets",
                                      std::move(compile_targets));
diff --git a/tools/gn/command_desc.cc b/tools/gn/command_desc.cc
index 8dbe6de..6203d01 100644
--- a/tools/gn/command_desc.cc
+++ b/tools/gn/command_desc.cc
@@ -5,12 +5,12 @@
 #include <stddef.h>
 
 #include <algorithm>
+#include <memory>
 #include <set>
 #include <sstream>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/config.h"
@@ -457,7 +457,7 @@
 
   if (json) {
     // Convert all targets/configs to JSON, serialize and print them
-    auto res = base::MakeUnique<base::DictionaryValue>();
+    auto res = std::make_unique<base::DictionaryValue>();
     if (!target_matches.empty()) {
       for (const auto* target : target_matches) {
         res->SetWithoutPathExpansion(
diff --git a/tools/gn/desc_builder.cc b/tools/gn/desc_builder.cc
index 38b78e8..ba5291e 100644
--- a/tools/gn/desc_builder.cc
+++ b/tools/gn/desc_builder.cc
@@ -2,9 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
 #include <set>
 
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/config.h"
@@ -114,7 +114,7 @@
 
   template <typename T>
   ValuePtr RenderValue(const std::vector<T>& vector) {
-    auto res = base::MakeUnique<base::ListValue>();
+    auto res = std::make_unique<base::ListValue>();
     for (const auto& v : vector)
       res->Append(RenderValue(v));
 
@@ -122,17 +122,17 @@
   }
 
   ValuePtr RenderValue(const std::string& s, bool optional = false) {
-    return (s.empty() && optional) ? base::MakeUnique<base::Value>()
+    return (s.empty() && optional) ? std::make_unique<base::Value>()
                                    : ValuePtr(new base::Value(s));
   }
 
   ValuePtr RenderValue(const SourceDir& d) {
-    return d.is_null() ? base::MakeUnique<base::Value>()
+    return d.is_null() ? std::make_unique<base::Value>()
                        : ValuePtr(new base::Value(FormatSourceDir(d)));
   }
 
   ValuePtr RenderValue(const SourceFile& f) {
-    return f.is_null() ? base::MakeUnique<base::Value>()
+    return f.is_null() ? std::make_unique<base::Value>()
                        : ValuePtr(new base::Value(f.value()));
   }
 
@@ -182,7 +182,7 @@
       : BaseDescBuilder(what, false, false, false), config_(config) {}
 
   std::unique_ptr<base::DictionaryValue> BuildDescription() {
-    auto res = base::MakeUnique<base::DictionaryValue>();
+    auto res = std::make_unique<base::DictionaryValue>();
     const ConfigValues& values = config_->resolved_values();
 
     if (what_.empty())
@@ -192,7 +192,7 @@
               config_->label().GetToolchainLabel().GetUserVisibleName(false)));
 
     if (what(variables::kConfigs) && !config_->configs().empty()) {
-      auto configs = base::MakeUnique<base::ListValue>();
+      auto configs = std::make_unique<base::ListValue>();
       FillInConfigVector(configs.get(), config_->configs().vector());
       res->SetWithoutPathExpansion(variables::kConfigs, std::move(configs));
     }
@@ -235,7 +235,7 @@
   ValuePtr render_config_value_array(
       const ConfigValues& values,
       const std::vector<T>& (ConfigValues::*getter)() const) {
-    auto res = base::MakeUnique<base::ListValue>();
+    auto res = std::make_unique<base::ListValue>();
 
     for (const T& cur : (values.*getter)())
       res->Append(RenderValue(cur));
@@ -256,7 +256,7 @@
       : BaseDescBuilder(what, all, tree, blame), target_(target) {}
 
   std::unique_ptr<base::DictionaryValue> BuildDescription() {
-    auto res = base::MakeUnique<base::DictionaryValue>();
+    auto res = std::make_unique<base::DictionaryValue>();
     bool is_binary_output = target_->IsBinary();
 
     if (what_.empty()) {
@@ -283,7 +283,7 @@
                     base::Value(target_->check_includes()));
 
       if (what(variables::kAllowCircularIncludesFrom)) {
-        auto labels = base::MakeUnique<base::ListValue>();
+        auto labels = std::make_unique<base::ListValue>();
         for (const auto& cur : target_->allow_circular_includes_from())
           labels->AppendString(cur.GetUserVisibleName(GetToolchainLabel()));
 
@@ -321,13 +321,13 @@
 
     if (is_binary_output && what(variables::kConfigs) &&
         !target_->configs().empty()) {
-      auto configs = base::MakeUnique<base::ListValue>();
+      auto configs = std::make_unique<base::ListValue>();
       FillInConfigVector(configs.get(), target_->configs().vector());
       res->SetWithoutPathExpansion(variables::kConfigs, std::move(configs));
     }
 
     if (what(variables::kPublicConfigs) && !target_->public_configs().empty()) {
-      auto configs = base::MakeUnique<base::ListValue>();
+      auto configs = std::make_unique<base::ListValue>();
       FillInConfigVector(configs.get(), target_->public_configs());
       res->SetWithoutPathExpansion(variables::kPublicConfigs,
                                    std::move(configs));
@@ -335,7 +335,7 @@
 
     if (what(variables::kAllDependentConfigs) &&
         !target_->all_dependent_configs().empty()) {
-      auto configs = base::MakeUnique<base::ListValue>();
+      auto configs = std::make_unique<base::ListValue>();
       FillInConfigVector(configs.get(), target_->all_dependent_configs());
       res->SetWithoutPathExpansion(variables::kAllDependentConfigs,
                                    std::move(configs));
@@ -349,7 +349,7 @@
                     base::Value(target_->action_values().script().value()));
 
       if (what(variables::kArgs)) {
-        auto args = base::MakeUnique<base::ListValue>();
+        auto args = std::make_unique<base::ListValue>();
         for (const auto& elem : target_->action_values().args().list())
           args->AppendString(elem.AsString());
 
@@ -419,7 +419,7 @@
     if (what(variables::kLibs)) {
       const OrderedSet<LibFile>& all_libs = target_->all_libs();
       if (!all_libs.empty()) {
-        auto libs = base::MakeUnique<base::ListValue>();
+        auto libs = std::make_unique<base::ListValue>();
         for (size_t i = 0; i < all_libs.size(); i++)
           libs->AppendString(all_libs[i].value());
         res->SetWithoutPathExpansion(variables::kLibs, std::move(libs));
@@ -429,7 +429,7 @@
     if (what(variables::kLibDirs)) {
       const OrderedSet<SourceDir>& all_lib_dirs = target_->all_lib_dirs();
       if (!all_lib_dirs.empty()) {
-        auto lib_dirs = base::MakeUnique<base::ListValue>();
+        auto lib_dirs = std::make_unique<base::ListValue>();
         for (size_t i = 0; i < all_lib_dirs.size(); i++)
           lib_dirs->AppendString(FormatSourceDir(all_lib_dirs[i]));
         res->SetWithoutPathExpansion(variables::kLibDirs, std::move(lib_dirs));
@@ -486,7 +486,7 @@
   }
 
   ValuePtr RenderDeps() {
-    auto res = base::MakeUnique<base::ListValue>();
+    auto res = std::make_unique<base::ListValue>();
 
     // Tree mode is separate.
     if (tree_) {
@@ -520,7 +520,7 @@
   }
 
   ValuePtr RenderRuntimeDeps() {
-    auto res = base::MakeUnique<base::ListValue>();
+    auto res = std::make_unique<base::ListValue>();
 
     const Target* previous_from = NULL;
     for (const auto& pair : ComputeRuntimeDeps(target_)) {
@@ -546,12 +546,12 @@
   }
 
   void FillInSourceOutputs(base::DictionaryValue* res) {
-    auto dict = base::MakeUnique<base::DictionaryValue>();
+    auto dict = std::make_unique<base::DictionaryValue>();
     for (const auto& source : target_->sources()) {
       std::vector<OutputFile> outputs;
       Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
       if (target_->GetOutputFilesForSource(source, &tool_type, &outputs)) {
-        auto list = base::MakeUnique<base::ListValue>();
+        auto list = std::make_unique<base::ListValue>();
         for (const auto& output : outputs)
           list->AppendString(output.value());
 
@@ -562,7 +562,7 @@
   }
 
   void FillInBundle(base::DictionaryValue* res) {
-    auto data = base::MakeUnique<base::DictionaryValue>();
+    auto data = std::make_unique<base::DictionaryValue>();
     const BundleData& bundle_data = target_->bundle_data();
     const Settings* settings = target_->settings();
     BundleData::SourceFiles sources;
@@ -583,7 +583,7 @@
     data->SetWithoutPathExpansion(
         "partial_info_plist", RenderValue(bundle_data.partial_info_plist()));
 
-    auto deps = base::MakeUnique<base::ListValue>();
+    auto deps = std::make_unique<base::ListValue>();
     for (const auto* dep : bundle_data.bundle_deps())
       deps->AppendString(dep->label().GetUserVisibleName(GetToolchainLabel()));
 
@@ -593,7 +593,7 @@
 
   void FillInOutputs(base::DictionaryValue* res) {
     if (target_->output_type() == Target::ACTION) {
-      auto list = base::MakeUnique<base::ListValue>();
+      auto list = std::make_unique<base::ListValue>();
       for (const auto& elem : target_->action_values().outputs().list())
         list->AppendString(elem.AsString());
 
@@ -608,7 +608,7 @@
                target_->output_type() == Target::COPY_FILES) {
       const SubstitutionList& outputs = target_->action_values().outputs();
       if (!outputs.required_types().empty()) {
-        auto patterns = base::MakeUnique<base::ListValue>();
+        auto patterns = std::make_unique<base::ListValue>();
         for (const auto& elem : outputs.list())
           patterns->AppendString(elem.AsString());
 
@@ -644,7 +644,7 @@
   template <class T>
   ValuePtr RenderConfigValues(const std::vector<T>& (ConfigValues::*getter)()
                                   const) {
-    auto res = base::MakeUnique<base::ListValue>();
+    auto res = std::make_unique<base::ListValue>();
     for (ConfigValuesIterator iter(target_); !iter.done(); iter.Next()) {
       const std::vector<T>& vec = (iter.cur().*getter)();
 
@@ -678,7 +678,7 @@
         // Indent string values in blame mode
         if (blame_ && rendered->GetAsString(&str)) {
           str = "  " + str;
-          rendered = base::MakeUnique<base::Value>(str);
+          rendered = std::make_unique<base::Value>(str);
         }
         res->Append(std::move(rendered));
       }
diff --git a/tools/gn/function_get_target_outputs_unittest.cc b/tools/gn/function_get_target_outputs_unittest.cc
index abe07d4..d7354eb 100644
--- a/tools/gn/function_get_target_outputs_unittest.cc
+++ b/tools/gn/function_get_target_outputs_unittest.cc
@@ -2,9 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/target.h"
@@ -61,7 +61,7 @@
 
 TEST_F(GetTargetOutputsTest, Copy) {
   auto action =
-      base::MakeUnique<Target>(setup_.settings(), GetLabel("//foo/", "bar"));
+      std::make_unique<Target>(setup_.settings(), GetLabel("//foo/", "bar"));
   action->set_output_type(Target::COPY_FILES);
   action->sources().push_back(SourceFile("//file.txt"));
   action->action_values().outputs() =
@@ -77,7 +77,7 @@
 
 TEST_F(GetTargetOutputsTest, Action) {
   auto action =
-      base::MakeUnique<Target>(setup_.settings(), GetLabel("//foo/", "bar"));
+      std::make_unique<Target>(setup_.settings(), GetLabel("//foo/", "bar"));
   action->set_output_type(Target::ACTION);
   action->action_values().outputs() = SubstitutionList::MakeForTest(
       "//output1.txt",
@@ -93,7 +93,7 @@
 
 TEST_F(GetTargetOutputsTest, ActionForeach) {
   auto action =
-      base::MakeUnique<Target>(setup_.settings(), GetLabel("//foo/", "bar"));
+      std::make_unique<Target>(setup_.settings(), GetLabel("//foo/", "bar"));
   action->set_output_type(Target::ACTION_FOREACH);
   action->sources().push_back(SourceFile("//file.txt"));
   action->action_values().outputs() = SubstitutionList::MakeForTest(
diff --git a/tools/gn/function_toolchain.cc b/tools/gn/function_toolchain.cc
index 2d80273..aeeb4e1 100644
--- a/tools/gn/function_toolchain.cc
+++ b/tools/gn/function_toolchain.cc
@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <utility>
 
 #include "tools/gn/err.h"
@@ -453,7 +454,8 @@
 
   // This object will actually be copied into the one owned by the toolchain
   // manager, but that has to be done in the lock.
-  std::unique_ptr<Toolchain> toolchain(new Toolchain(scope->settings(), label));
+  std::unique_ptr<Toolchain> toolchain =
+      std::make_unique<Toolchain>(scope->settings(), label);
   toolchain->set_defined_from(function);
   toolchain->visibility().SetPublic();
 
@@ -1022,7 +1024,7 @@
     subst_output_validator = &IsValidToolSubstitution;
   }
 
-  std::unique_ptr<Tool> tool(new Tool);
+  std::unique_ptr<Tool> tool = std::make_unique<Tool>();
   tool->set_defined_from(function);
 
   if (!ReadPattern(&block_scope, "command", subst_validator, tool.get(),
diff --git a/tools/gn/functions.cc b/tools/gn/functions.cc
index 4e469ac..60a6eb7 100644
--- a/tools/gn/functions.cc
+++ b/tools/gn/functions.cc
@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 #include <iostream>
+#include <memory>
 #include <utility>
 
 #include "base/environment.h"
@@ -337,7 +338,8 @@
     g_scheduler->Log("Defining config", label.GetUserVisibleName(true));
 
   // Create the new config.
-  std::unique_ptr<Config> config(new Config(scope->settings(), label));
+  std::unique_ptr<Config> config =
+      std::make_unique<Config>(scope->settings(), label);
   config->set_defined_from(function);
   if (!Visibility::FillItemVisibility(config.get(), scope, err))
     return Value();
@@ -825,7 +827,7 @@
   if (args.size() != 1) {
     *err = Err(function, "set_sources_assignment_filter takes one argument.");
   } else {
-    std::unique_ptr<PatternList> f(new PatternList);
+    std::unique_ptr<PatternList> f = std::make_unique<PatternList>();
     f->SetFromValue(args[0], err);
     if (!err->has_error())
       scope->set_sources_assignment_filter(std::move(f));
@@ -908,7 +910,7 @@
   }
 
   // Create the new pool.
-  std::unique_ptr<Pool> pool(new Pool(scope->settings(), label));
+  std::unique_ptr<Pool> pool = std::make_unique<Pool>(scope->settings(), label);
   pool->set_depth(depth->int_value());
 
   // Save the generated item.
diff --git a/tools/gn/functions_unittest.cc b/tools/gn/functions_unittest.cc
index 949b844..1ed509a 100644
--- a/tools/gn/functions_unittest.cc
+++ b/tools/gn/functions_unittest.cc
@@ -4,9 +4,9 @@
 
 #include "tools/gn/functions.h"
 
+#include <memory>
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/test_with_scope.h"
@@ -22,7 +22,7 @@
   Token undefined_token(Location(), Token::IDENTIFIER, "undef");
   ListNode args_list_identifier_undefined;
   args_list_identifier_undefined.append_item(
-      std::unique_ptr<ParseNode>(new IdentifierNode(undefined_token)));
+      std::make_unique<IdentifierNode>(undefined_token));
   Value result = functions::RunDefined(setup.scope(), &function_call,
                                        &args_list_identifier_undefined, &err);
   ASSERT_EQ(Value::BOOLEAN, result.type());
@@ -31,14 +31,13 @@
   // Define a value that's itself a scope value.
   const char kDef[] = "def";  // Defined variable name.
   setup.scope()->SetValue(
-      kDef, Value(nullptr, std::unique_ptr<Scope>(new Scope(setup.scope()))),
-      nullptr);
+      kDef, Value(nullptr, std::make_unique<Scope>(setup.scope())), nullptr);
 
   // Test the defined identifier.
   Token defined_token(Location(), Token::IDENTIFIER, kDef);
   ListNode args_list_identifier_defined;
   args_list_identifier_defined.append_item(
-      std::unique_ptr<ParseNode>(new IdentifierNode(defined_token)));
+      std::make_unique<IdentifierNode>(defined_token));
   result = functions::RunDefined(setup.scope(), &function_call,
                                  &args_list_identifier_defined, &err);
   ASSERT_EQ(Value::BOOLEAN, result.type());
@@ -46,9 +45,10 @@
 
   // Should also work by passing an accessor node so you can do
   // "defined(def.foo)" to see if foo is defined on the def scope.
-  std::unique_ptr<AccessorNode> undef_accessor(new AccessorNode);
+  std::unique_ptr<AccessorNode> undef_accessor =
+      std::make_unique<AccessorNode>();
   undef_accessor->set_base(defined_token);
-  undef_accessor->set_member(base::MakeUnique<IdentifierNode>(undefined_token));
+  undef_accessor->set_member(std::make_unique<IdentifierNode>(undefined_token));
   ListNode args_list_accessor_defined;
   args_list_accessor_defined.append_item(std::move(undef_accessor));
   result = functions::RunDefined(setup.scope(), &function_call,
diff --git a/tools/gn/import_manager.cc b/tools/gn/import_manager.cc
index c9a44d4..b94ea70 100644
--- a/tools/gn/import_manager.cc
+++ b/tools/gn/import_manager.cc
@@ -4,6 +4,8 @@
 
 #include "tools/gn/import_manager.h"
 
+#include <memory>
+
 #include "tools/gn/err.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scheduler.h"
@@ -24,7 +26,8 @@
   if (!node)
     return nullptr;
 
-  std::unique_ptr<Scope> scope(new Scope(settings->base_config()));
+  std::unique_ptr<Scope> scope =
+      std::make_unique<Scope>(settings->base_config());
   scope->set_source_dir(file.GetDir());
 
   // Don't allow ScopePerFileProvider to provide target-related variables.
@@ -80,7 +83,7 @@
     base::AutoLock lock(imports_lock_);
     std::unique_ptr<ImportInfo>& info_ptr = imports_[file];
     if (!info_ptr)
-      info_ptr.reset(new ImportInfo);
+      info_ptr = std::make_unique<ImportInfo>();
 
     // Promote the ImportInfo to outside of the imports lock.
     import_info = info_ptr.get();
diff --git a/tools/gn/input_conversion.cc b/tools/gn/input_conversion.cc
index 2e905c6..7cce107 100644
--- a/tools/gn/input_conversion.cc
+++ b/tools/gn/input_conversion.cc
@@ -4,6 +4,7 @@
 
 #include "tools/gn/input_conversion.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/macros.h"
@@ -74,7 +75,7 @@
   if (!parse_root)
     return Value();
 
-  std::unique_ptr<Scope> scope(new Scope(settings));
+  std::unique_ptr<Scope> scope = std::make_unique<Scope>(settings);
   Value result = parse_root->Execute(scope.get(), err);
   if (err->has_error())
     return Value();
diff --git a/tools/gn/input_file_manager.cc b/tools/gn/input_file_manager.cc
index 9fd3def..9f92130 100644
--- a/tools/gn/input_file_manager.cc
+++ b/tools/gn/input_file_manager.cc
@@ -4,6 +4,7 @@
 
 #include "tools/gn/input_file_manager.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ -111,7 +112,8 @@
     InputFileMap::const_iterator found = input_files_.find(file_name);
     if (found == input_files_.end()) {
       // New file, schedule load.
-      std::unique_ptr<InputFileData> data(new InputFileData(file_name));
+      std::unique_ptr<InputFileData> data =
+          std::make_unique<InputFileData>(file_name);
       data->scheduled_callbacks.push_back(callback);
       schedule_this = base::Bind(&InputFileManager::BackgroundLoadFile,
                                  this,
@@ -162,7 +164,8 @@
   InputFileMap::iterator found = input_files_.find(file_name);
   if (found == input_files_.end()) {
     // Haven't seen this file yet, start loading right now.
-    std::unique_ptr<InputFileData> new_data(new InputFileData(file_name));
+    std::unique_ptr<InputFileData> new_data =
+        std::make_unique<InputFileData>(file_name);
     data = new_data.get();
     data->sync_invocation = true;
     input_files_[file_name] = std::move(new_data);
@@ -202,9 +205,9 @@
     if (!data->loaded) {
       // Wait for the already-pending sync load to complete.
       if (!data->completion_event) {
-        data->completion_event.reset(new base::WaitableEvent(
+        data->completion_event = std::make_unique<base::WaitableEvent>(
             base::WaitableEvent::ResetPolicy::AUTOMATIC,
-            base::WaitableEvent::InitialState::NOT_SIGNALED));
+            base::WaitableEvent::InitialState::NOT_SIGNALED);
       }
       {
         base::AutoUnlock unlock(lock_);
@@ -230,7 +233,7 @@
     InputFile** file,
     std::vector<Token>** tokens,
     std::unique_ptr<ParseNode>** parse_root) {
-  std::unique_ptr<InputFileData> data(new InputFileData(name));
+  std::unique_ptr<InputFileData> data = std::make_unique<InputFileData>(name);
   *file = &data->file;
   *tokens = &data->tokens;
   *parse_root = &data->parsed_root;
diff --git a/tools/gn/json_project_writer.cc b/tools/gn/json_project_writer.cc
index dfb3cdb..4f4b0e7 100644
--- a/tools/gn/json_project_writer.cc
+++ b/tools/gn/json_project_writer.cc
@@ -5,10 +5,10 @@
 #include "tools/gn/json_project_writer.h"
 
 #include <iostream>
+#include <memory>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "tools/gn/builder.h"
 #include "tools/gn/commands.h"
@@ -86,7 +86,7 @@
                        std::vector<const Target*>& all_targets) {
   Label default_toolchain_label;
 
-  auto targets = base::MakeUnique<base::DictionaryValue>();
+  auto targets = std::make_unique<base::DictionaryValue>();
   for (const auto* target : all_targets) {
     if (default_toolchain_label.is_null())
       default_toolchain_label = target->settings()->default_toolchain_label();
@@ -105,7 +105,7 @@
         std::move(description));
   }
 
-  auto settings = base::MakeUnique<base::DictionaryValue>();
+  auto settings = std::make_unique<base::DictionaryValue>();
   settings->SetKey("root_path", base::Value(build_settings->root_path_utf8()));
   settings->SetKey("build_dir",
                    base::Value(build_settings->build_dir().value()));
@@ -113,7 +113,7 @@
       "default_toolchain",
       base::Value(default_toolchain_label.GetUserVisibleName(false)));
 
-  auto output = base::MakeUnique<base::DictionaryValue>();
+  auto output = std::make_unique<base::DictionaryValue>();
   output->SetWithoutPathExpansion("targets", std::move(targets));
   output->SetWithoutPathExpansion("build_settings", std::move(settings));
 
diff --git a/tools/gn/loader.cc b/tools/gn/loader.cc
index ba214c2..57680e0 100644
--- a/tools/gn/loader.cc
+++ b/tools/gn/loader.cc
@@ -4,8 +4,9 @@
 
 #include "tools/gn/loader.h"
 
+#include <memory>
+
 #include "base/bind.h"
-#include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/err.h"
@@ -123,8 +124,8 @@
     // should not specify a toolchain.
     DCHECK(toolchain_name.is_null());
 
-    std::unique_ptr<ToolchainRecord> new_record(
-        new ToolchainRecord(build_settings_, Label(), Label()));
+    std::unique_ptr<ToolchainRecord> new_record =
+        std::make_unique<ToolchainRecord>(build_settings_, Label(), Label());
     ToolchainRecord* record = new_record.get();
     toolchain_records_[Label()] = std::move(new_record);
 
@@ -149,8 +150,9 @@
     DCHECK(!default_toolchain_label_.is_null());
 
     // No reference to this toolchain found yet, make one.
-    std::unique_ptr<ToolchainRecord> new_record(new ToolchainRecord(
-        build_settings_, toolchain_name, default_toolchain_label_));
+    std::unique_ptr<ToolchainRecord> new_record =
+        std::make_unique<ToolchainRecord>(build_settings_, toolchain_name,
+                                          default_toolchain_label_);
     record = new_record.get();
     toolchain_records_[toolchain_name] = std::move(new_record);
 
@@ -168,8 +170,9 @@
   ToolchainRecord* record = toolchain_records_[toolchain->label()].get();
   if (!record) {
     DCHECK(!default_toolchain_label_.is_null());
-    std::unique_ptr<ToolchainRecord> new_record(new ToolchainRecord(
-        build_settings_, toolchain->label(), default_toolchain_label_));
+    std::unique_ptr<ToolchainRecord> new_record =
+        std::make_unique<ToolchainRecord>(build_settings_, toolchain->label(),
+                                          default_toolchain_label_);
     record = new_record.get();
     toolchain_records_[toolchain->label()] = std::move(new_record);
   }
diff --git a/tools/gn/loader_unittest.cc b/tools/gn/loader_unittest.cc
index 20b8609..fb33e5e 100644
--- a/tools/gn/loader_unittest.cc
+++ b/tools/gn/loader_unittest.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include <map>
+#include <memory>
 #include <utility>
 #include <vector>
 
@@ -68,8 +69,8 @@
 // Sets a given response for a given source file.
 void MockInputFileManager::AddCannedResponse(const SourceFile& source_file,
                                              const std::string& source) {
-  std::unique_ptr<CannedResult> canned(new CannedResult);
-  canned->input_file.reset(new InputFile(source_file));
+  std::unique_ptr<CannedResult> canned = std::make_unique<CannedResult>();
+  canned->input_file = std::make_unique<InputFile>(source_file);
   canned->input_file->SetContents(source);
 
   // Tokenize.
diff --git a/tools/gn/ninja_binary_target_writer_unittest.cc b/tools/gn/ninja_binary_target_writer_unittest.cc
index fc0b328..71804ef 100644
--- a/tools/gn/ninja_binary_target_writer_unittest.cc
+++ b/tools/gn/ninja_binary_target_writer_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "tools/gn/ninja_binary_target_writer.h"
 
+#include <memory>
 #include <sstream>
 #include <utility>
 
@@ -582,7 +583,7 @@
   pch_settings.set_default_toolchain_label(setup.toolchain()->label());
 
   // Declare a C++ compiler that supports PCH.
-  std::unique_ptr<Tool> cxx_tool(new Tool);
+  std::unique_ptr<Tool> cxx_tool = std::make_unique<Tool>();
   TestWithScope::SetCommandForTool(
       "c++ {{source}} {{cflags}} {{cflags_cc}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
@@ -593,7 +594,7 @@
   pch_toolchain.SetTool(Toolchain::TYPE_CXX, std::move(cxx_tool));
 
   // Add a C compiler as well.
-  std::unique_ptr<Tool> cc_tool(new Tool);
+  std::unique_ptr<Tool> cc_tool = std::make_unique<Tool>();
   TestWithScope::SetCommandForTool(
       "cc {{source}} {{cflags}} {{cflags_c}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
@@ -709,7 +710,7 @@
   pch_settings.set_default_toolchain_label(setup.toolchain()->label());
 
   // Declare a C++ compiler that supports PCH.
-  std::unique_ptr<Tool> cxx_tool(new Tool);
+  std::unique_ptr<Tool> cxx_tool = std::make_unique<Tool>();
   TestWithScope::SetCommandForTool(
       "c++ {{source}} {{cflags}} {{cflags_cc}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
@@ -721,7 +722,7 @@
   pch_toolchain.ToolchainSetupComplete();
 
   // Add a C compiler as well.
-  std::unique_ptr<Tool> cc_tool(new Tool);
+  std::unique_ptr<Tool> cc_tool = std::make_unique<Tool>();
   TestWithScope::SetCommandForTool(
       "cc {{source}} {{cflags}} {{cflags_c}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
diff --git a/tools/gn/operators_unittest.cc b/tools/gn/operators_unittest.cc
index d72e08b..4b8ab37 100644
--- a/tools/gn/operators_unittest.cc
+++ b/tools/gn/operators_unittest.cc
@@ -5,6 +5,8 @@
 #include "tools/gn/operators.h"
 
 #include <stdint.h>
+
+#include <memory>
 #include <utility>
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ -62,7 +64,7 @@
   }
 
   void SetLeftToValue(const Value& value) {
-    set_left(std::unique_ptr<ParseNode>(new TestParseNode(value)));
+    set_left(std::make_unique<TestParseNode>(value));
   }
 
   // Sets the left-hand side of the operator to an identifier node, this is
@@ -70,23 +72,23 @@
   void SetLeftToIdentifier(const char* identifier) {
     left_identifier_token_ownership_ =
         Token(Location(), Token::IDENTIFIER, identifier);
-    set_left(std::unique_ptr<ParseNode>(
-        new IdentifierNode(left_identifier_token_ownership_)));
+    set_left(
+        std::make_unique<IdentifierNode>(left_identifier_token_ownership_));
   }
 
   void SetRightToValue(const Value& value) {
-    set_right(std::unique_ptr<ParseNode>(new TestParseNode(value)));
+    set_right(std::make_unique<TestParseNode>(value));
   }
   void SetRightToListOfValue(const Value& value) {
     Value list(nullptr, Value::LIST);
     list.list_value().push_back(value);
-    set_right(std::unique_ptr<ParseNode>(new TestParseNode(list)));
+    set_right(std::make_unique<TestParseNode>(list));
   }
   void SetRightToListOfValue(const Value& value1, const Value& value2) {
     Value list(nullptr, Value::LIST);
     list.list_value().push_back(value1);
     list.list_value().push_back(value2);
-    set_right(std::unique_ptr<ParseNode>(new TestParseNode(list)));
+    set_right(std::make_unique<TestParseNode>(list));
   }
 
  private:
@@ -113,7 +115,7 @@
   node.SetLeftToIdentifier(sources);
 
   // Set up the filter on the scope to remove everything ending with "rm"
-  std::unique_ptr<PatternList> pattern_list(new PatternList);
+  std::unique_ptr<PatternList> pattern_list = std::make_unique<PatternList>();
   pattern_list->Append(Pattern("*rm"));
   setup.scope()->set_sources_assignment_filter(std::move(pattern_list));
 
@@ -189,7 +191,7 @@
   // This should fail.
   const char str_str[] = "\"hi\"";
   Token str(Location(), Token::STRING, str_str);
-  node.set_right(std::unique_ptr<ParseNode>(new LiteralNode(str)));
+  node.set_right(std::make_unique<LiteralNode>(str));
   ExecuteBinaryOperator(setup.scope(), &node, node.left(), node.right(), &err);
   EXPECT_TRUE(err.has_error());
   err = Err();
@@ -276,8 +278,7 @@
   // Set right as foo, but don't define a value for it.
   const char foo[] = "foo";
   Token identifier_token(Location(), Token::IDENTIFIER, foo);
-  node.set_right(
-      std::unique_ptr<ParseNode>(new IdentifierNode(identifier_token)));
+  node.set_right(std::make_unique<IdentifierNode>(identifier_token));
 
   Value ret = ExecuteBinaryOperator(setup.scope(), &node, node.left(),
                                     node.right(), &err);
@@ -295,8 +296,7 @@
   // Set right as foo, but don't define a value for it.
   const char foo[] = "foo";
   Token identifier_token(Location(), Token::IDENTIFIER, foo);
-  node.set_right(
-      std::unique_ptr<ParseNode>(new IdentifierNode(identifier_token)));
+  node.set_right(std::make_unique<IdentifierNode>(identifier_token));
 
   Value ret = ExecuteBinaryOperator(setup.scope(), &node, node.left(),
                                     node.right(), &err);
@@ -336,8 +336,7 @@
 
   // Set up "foo" with a nonempty scope.
   const char bar[] = "bar";
-  old_value =
-      Value(nullptr, std::unique_ptr<Scope>(new Scope(setup.settings())));
+  old_value = Value(nullptr, std::make_unique<Scope>(setup.settings()));
   old_value.scope_value()->SetValue(bar, Value(nullptr, "bar"), nullptr);
   setup.scope()->SetValue(foo, old_value, nullptr);
 
@@ -350,7 +349,7 @@
 
   // Assigning an empty list should succeed.
   node.SetRightToValue(
-      Value(nullptr, std::unique_ptr<Scope>(new Scope(setup.settings()))));
+      Value(nullptr, std::make_unique<Scope>(setup.settings())));
   node.Execute(setup.scope(), &err);
   ASSERT_FALSE(err.has_error());
   new_value = setup.scope()->GetValue(foo);
diff --git a/tools/gn/parse_tree.cc b/tools/gn/parse_tree.cc
index d1de9cb..3dae3e6 100644
--- a/tools/gn/parse_tree.cc
+++ b/tools/gn/parse_tree.cc
@@ -6,6 +6,7 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <tuple>
 
@@ -110,7 +111,7 @@
 
 Comments* ParseNode::comments_mutable() {
   if (!comments_)
-    comments_.reset(new Comments);
+    comments_ = std::make_unique<Comments>();
   return comments_.get();
 }
 
@@ -315,7 +316,7 @@
   Scope* execution_scope;  // Either the enclosing_scope or nested_scope.
   if (result_mode_ == RETURNS_SCOPE) {
     // Create a nested scope to save the values for returning.
-    nested_scope.reset(new Scope(enclosing_scope));
+    nested_scope = std::make_unique<Scope>(enclosing_scope);
     execution_scope = nested_scope.get();
   } else {
     // Use the enclosing scope. Modifications will go into this also (for
diff --git a/tools/gn/parse_tree_unittest.cc b/tools/gn/parse_tree_unittest.cc
index 0609215..a786925 100644
--- a/tools/gn/parse_tree_unittest.cc
+++ b/tools/gn/parse_tree_unittest.cc
@@ -5,6 +5,8 @@
 #include "tools/gn/parse_tree.h"
 
 #include <stdint.h>
+
+#include <memory>
 #include <utility>
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ -24,8 +26,8 @@
   AccessorNode accessor;
   accessor.set_base(base_token);
 
-  std::unique_ptr<IdentifierNode> member_identifier(
-      new IdentifierNode(member_token));
+  std::unique_ptr<IdentifierNode> member_identifier =
+      std::make_unique<IdentifierNode>(member_token);
   accessor.set_member(std::move(member_identifier));
 
   // The access should fail because a is not defined.
@@ -37,8 +39,7 @@
   // Define a as a Scope. It should still fail because b isn't defined.
   err = Err();
   setup.scope()->SetValue(
-      "a", Value(nullptr, std::unique_ptr<Scope>(new Scope(setup.scope()))),
-      nullptr);
+      "a", Value(nullptr, std::make_unique<Scope>(setup.scope())), nullptr);
   result = accessor.Execute(setup.scope(), &err);
   EXPECT_TRUE(err.has_error());
   EXPECT_EQ(Value::NONE, result.type());
diff --git a/tools/gn/parser.cc b/tools/gn/parser.cc
index 7e2c7f4..cc146e4 100644
--- a/tools/gn/parser.cc
+++ b/tools/gn/parser.cc
@@ -4,10 +4,10 @@
 
 #include "tools/gn/parser.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/operators.h"
 #include "tools/gn/token.h"
@@ -460,7 +460,7 @@
 }
 
 std::unique_ptr<ParseNode> Parser::Literal(const Token& token) {
-  return base::MakeUnique<LiteralNode>(token);
+  return std::make_unique<LiteralNode>(token);
 }
 
 std::unique_ptr<ParseNode> Parser::Name(const Token& token) {
@@ -468,7 +468,8 @@
 }
 
 std::unique_ptr<ParseNode> Parser::BlockComment(const Token& token) {
-  std::unique_ptr<BlockCommentNode> comment(new BlockCommentNode());
+  std::unique_ptr<BlockCommentNode> comment =
+      std::make_unique<BlockCommentNode>();
   comment->set_comment(token);
   return std::move(comment);
 }
@@ -490,7 +491,7 @@
       *err_ = Err(token, "Expected right-hand side for '!'.");
     return std::unique_ptr<ParseNode>();
   }
-  std::unique_ptr<UnaryOpNode> unary_op(new UnaryOpNode);
+  std::unique_ptr<UnaryOpNode> unary_op = std::make_unique<UnaryOpNode>();
   unary_op->set_op(token);
   unary_op->set_operand(std::move(expr));
   return std::move(unary_op);
@@ -515,7 +516,7 @@
     }
     return std::unique_ptr<ParseNode>();
   }
-  std::unique_ptr<BinaryOpNode> binary_op(new BinaryOpNode);
+  std::unique_ptr<BinaryOpNode> binary_op = std::make_unique<BinaryOpNode>();
   binary_op->set_op(token);
   binary_op->set_left(std::move(left));
   binary_op->set_right(std::move(right));
@@ -525,9 +526,9 @@
 std::unique_ptr<ParseNode> Parser::IdentifierOrCall(
     std::unique_ptr<ParseNode> left,
     const Token& token) {
-  std::unique_ptr<ListNode> list(new ListNode);
+  std::unique_ptr<ListNode> list = std::make_unique<ListNode>();
   list->set_begin_token(token);
-  list->set_end(base::MakeUnique<EndNode>(token));
+  list->set_end(std::make_unique<EndNode>(token));
   std::unique_ptr<BlockNode> block;
   bool has_arg = false;
   if (LookAhead(Token::LEFT_PAREN)) {
@@ -552,9 +553,10 @@
 
   if (!left && !has_arg) {
     // Not a function call, just a standalone identifier.
-    return std::unique_ptr<ParseNode>(new IdentifierNode(token));
+    return std::make_unique<IdentifierNode>(token);
   }
-  std::unique_ptr<FunctionCallNode> func_call(new FunctionCallNode);
+  std::unique_ptr<FunctionCallNode> func_call =
+      std::make_unique<FunctionCallNode>();
   func_call->set_function(token);
   func_call->set_args(std::move(list));
   if (block)
@@ -576,7 +578,7 @@
       *err_ = Err(token, "Expected right-hand side for assignment.");
     return std::unique_ptr<ParseNode>();
   }
-  std::unique_ptr<BinaryOpNode> assign(new BinaryOpNode);
+  std::unique_ptr<BinaryOpNode> assign = std::make_unique<BinaryOpNode>();
   assign->set_op(token);
   assign->set_left(std::move(left));
   assign->set_right(std::move(value));
@@ -596,7 +598,7 @@
   }
   std::unique_ptr<ParseNode> value = ParseExpression();
   Consume(Token::RIGHT_BRACKET, "Expecting ']' after subscript.");
-  std::unique_ptr<AccessorNode> accessor(new AccessorNode);
+  std::unique_ptr<AccessorNode> accessor = std::make_unique<AccessorNode>();
   accessor->set_base(left->AsIdentifier()->value());
   accessor->set_index(std::move(value));
   return std::move(accessor);
@@ -619,7 +621,7 @@
     return std::unique_ptr<ParseNode>();
   }
 
-  std::unique_ptr<AccessorNode> accessor(new AccessorNode);
+  std::unique_ptr<AccessorNode> accessor = std::make_unique<AccessorNode>();
   accessor->set_base(left->AsIdentifier()->value());
   accessor->set_member(std::unique_ptr<IdentifierNode>(
       static_cast<IdentifierNode*>(right.release())));
@@ -630,7 +632,7 @@
 std::unique_ptr<ListNode> Parser::ParseList(const Token& start_token,
                                             Token::Type stop_before,
                                             bool allow_trailing_comma) {
-  std::unique_ptr<ListNode> list(new ListNode);
+  std::unique_ptr<ListNode> list = std::make_unique<ListNode>();
   list->set_begin_token(start_token);
   bool just_got_comma = false;
   bool first_time = true;
@@ -667,12 +669,13 @@
     *err_ = Err(cur_token(), "Trailing comma");
     return std::unique_ptr<ListNode>();
   }
-  list->set_end(base::MakeUnique<EndNode>(cur_token()));
+  list->set_end(std::make_unique<EndNode>(cur_token()));
   return list;
 }
 
 std::unique_ptr<ParseNode> Parser::ParseFile() {
-  std::unique_ptr<BlockNode> file(new BlockNode(BlockNode::DISCARDS_RESULT));
+  std::unique_ptr<BlockNode> file =
+      std::make_unique<BlockNode>(BlockNode::DISCARDS_RESULT);
   for (;;) {
     if (at_end())
       break;
@@ -721,12 +724,12 @@
     BlockNode::ResultMode result_mode) {
   if (has_error())
     return std::unique_ptr<BlockNode>();
-  std::unique_ptr<BlockNode> block(new BlockNode(result_mode));
+  std::unique_ptr<BlockNode> block = std::make_unique<BlockNode>(result_mode);
   block->set_begin_token(begin_brace);
 
   for (;;) {
     if (LookAhead(Token::RIGHT_BRACE)) {
-      block->set_end(base::MakeUnique<EndNode>(Consume()));
+      block->set_end(std::make_unique<EndNode>(Consume()));
       break;
     }
 
@@ -739,7 +742,7 @@
 }
 
 std::unique_ptr<ParseNode> Parser::ParseCondition() {
-  std::unique_ptr<ConditionNode> condition(new ConditionNode);
+  std::unique_ptr<ConditionNode> condition = std::make_unique<ConditionNode>();
   condition->set_if_token(Consume(Token::IF, "Expected 'if'"));
   Consume(Token::LEFT_PAREN, "Expected '(' after 'if'.");
   condition->set_condition(ParseExpression());
diff --git a/tools/gn/scope.cc b/tools/gn/scope.cc
index 024d5ec..6802a5a 100644
--- a/tools/gn/scope.cc
+++ b/tools/gn/scope.cc
@@ -4,8 +4,9 @@
 
 #include "tools/gn/scope.h"
 
+#include <memory>
+
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/template.h"
 
@@ -346,7 +347,7 @@
     }
 
     std::unique_ptr<Scope>& dest_scope = dest->target_defaults_[current_name];
-    dest_scope = base::MakeUnique<Scope>(settings_);
+    dest_scope = std::make_unique<Scope>(settings_);
     pair.second->NonRecursiveMergeTo(dest_scope.get(), options, node_for_err,
                                      "<SHOULDN'T HAPPEN>", err);
   }
@@ -363,8 +364,8 @@
         return false;
       }
     }
-    dest->sources_assignment_filter_.reset(
-        new PatternList(*sources_assignment_filter_));
+    dest->sources_assignment_filter_ =
+        std::make_unique<PatternList>(*sources_assignment_filter_);
   }
 
   // Templates.
@@ -412,14 +413,14 @@
   if (const_containing_) {
     // We reached the top of the mutable scope stack. The result scope just
     // references the const scope (which will never change).
-    result.reset(new Scope(const_containing_));
+    result = std::make_unique<Scope>(const_containing_);
   } else if (mutable_containing_) {
     // There are more nested mutable scopes. Recursively go up the stack to
     // get the closure.
     result = mutable_containing_->MakeClosure();
   } else {
     // This is a standalone scope, just copy it.
-    result.reset(new Scope(settings_));
+    result = std::make_unique<Scope>(settings_);
   }
 
   // Want to clobber since we've flattened some nested scopes, and our parent
@@ -437,7 +438,7 @@
 
 Scope* Scope::MakeTargetDefaults(const std::string& target_type) {
   std::unique_ptr<Scope>& dest = target_defaults_[target_type];
-  dest = base::MakeUnique<Scope>(settings_);
+  dest = std::make_unique<Scope>(settings_);
   return dest.get();
 }
 
diff --git a/tools/gn/scope_per_file_provider.cc b/tools/gn/scope_per_file_provider.cc
index 737a5cd..f8c6026 100644
--- a/tools/gn/scope_per_file_provider.cc
+++ b/tools/gn/scope_per_file_provider.cc
@@ -4,6 +4,8 @@
 
 #include "tools/gn/scope_per_file_provider.h"
 
+#include <memory>
+
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/source_file.h"
@@ -46,77 +48,73 @@
 
 const Value* ScopePerFileProvider::GetCurrentToolchain() {
   if (!current_toolchain_) {
-    current_toolchain_.reset(new Value(
+    current_toolchain_ = std::make_unique<Value>(
         nullptr,
-        scope_->settings()->toolchain_label().GetUserVisibleName(false)));
+        scope_->settings()->toolchain_label().GetUserVisibleName(false));
   }
   return current_toolchain_.get();
 }
 
 const Value* ScopePerFileProvider::GetDefaultToolchain() {
   if (!default_toolchain_) {
-    default_toolchain_.reset(new Value(
+    default_toolchain_ = std::make_unique<Value>(
         nullptr,
         scope_->settings()->default_toolchain_label().GetUserVisibleName(
-            false)));
+            false));
   }
   return default_toolchain_.get();
 }
 
 const Value* ScopePerFileProvider::GetPythonPath() {
   if (!python_path_) {
-    python_path_.reset(new Value(
+    python_path_ = std::make_unique<Value>(
         nullptr,
-        FilePathToUTF8(scope_->settings()->build_settings()->python_path())));
+        FilePathToUTF8(scope_->settings()->build_settings()->python_path()));
   }
   return python_path_.get();
 }
 
 const Value* ScopePerFileProvider::GetRootBuildDir() {
   if (!root_build_dir_) {
-    root_build_dir_.reset(new Value(
+    root_build_dir_ = std::make_unique<Value>(
         nullptr, DirectoryWithNoLastSlash(
-                     scope_->settings()->build_settings()->build_dir())));
+                     scope_->settings()->build_settings()->build_dir()));
   }
   return root_build_dir_.get();
 }
 
 const Value* ScopePerFileProvider::GetRootGenDir() {
   if (!root_gen_dir_) {
-    root_gen_dir_.reset(new Value(
-        nullptr,
-        DirectoryWithNoLastSlash(GetBuildDirAsSourceDir(
-            BuildDirContext(scope_), BuildDirType::GEN))));
+    root_gen_dir_ = std::make_unique<Value>(
+        nullptr, DirectoryWithNoLastSlash(GetBuildDirAsSourceDir(
+                     BuildDirContext(scope_), BuildDirType::GEN)));
   }
   return root_gen_dir_.get();
 }
 
 const Value* ScopePerFileProvider::GetRootOutDir() {
   if (!root_out_dir_) {
-    root_out_dir_.reset(new Value(
-        nullptr,
-        DirectoryWithNoLastSlash(GetScopeCurrentBuildDirAsSourceDir(
-            scope_, BuildDirType::TOOLCHAIN_ROOT))));
+    root_out_dir_ = std::make_unique<Value>(
+        nullptr, DirectoryWithNoLastSlash(GetScopeCurrentBuildDirAsSourceDir(
+                     scope_, BuildDirType::TOOLCHAIN_ROOT)));
   }
   return root_out_dir_.get();
 }
 
 const Value* ScopePerFileProvider::GetTargetGenDir() {
   if (!target_gen_dir_) {
-    target_gen_dir_.reset(new Value(
-        nullptr,
-        DirectoryWithNoLastSlash(
-            GetScopeCurrentBuildDirAsSourceDir(scope_, BuildDirType::GEN))));
+    target_gen_dir_ = std::make_unique<Value>(
+        nullptr, DirectoryWithNoLastSlash(GetScopeCurrentBuildDirAsSourceDir(
+                     scope_, BuildDirType::GEN)));
   }
   return target_gen_dir_.get();
 }
 
 const Value* ScopePerFileProvider::GetTargetOutDir() {
   if (!target_out_dir_) {
-    target_out_dir_.reset(new Value(
-        nullptr,
-        DirectoryWithNoLastSlash(
-            GetScopeCurrentBuildDirAsSourceDir(scope_, BuildDirType::OBJ))));
+    target_out_dir_ = std::make_unique<Value>(
+        nullptr, DirectoryWithNoLastSlash(GetScopeCurrentBuildDirAsSourceDir(
+                     scope_, BuildDirType::OBJ)));
   }
   return target_out_dir_.get();
 }
diff --git a/tools/gn/setup.cc b/tools/gn/setup.cc
index e3b01a4..50a304f 100644
--- a/tools/gn/setup.cc
+++ b/tools/gn/setup.cc
@@ -5,7 +5,9 @@
 #include "tools/gn/setup.h"
 
 #include <stdlib.h>
+
 #include <algorithm>
+#include <memory>
 #include <sstream>
 #include <utility>
 
@@ -423,7 +425,7 @@
 }
 
 bool Setup::FillArgsFromCommandLine(const std::string& args) {
-  args_input_file_.reset(new InputFile(SourceFile()));
+  args_input_file_ = std::make_unique<InputFile>(SourceFile());
   args_input_file_->SetContents(args);
   args_input_file_->set_friendly_name("the command-line \"--args\"");
   return FillArgsFromArgsInputFile();
@@ -447,7 +449,7 @@
   if (contents.empty())
     return true;  // Empty file, do nothing.
 
-  args_input_file_.reset(new InputFile(build_arg_source_file));
+  args_input_file_ = std::make_unique<InputFile>(build_arg_source_file);
   args_input_file_->SetContents(contents);
   args_input_file_->set_friendly_name(
       "build arg file (use \"gn args <out_dir>\" to edit)");
@@ -668,7 +670,7 @@
   if (scheduler_.verbose_logging())
     scheduler_.Log("Got dotfile", FilePathToUTF8(dotfile_name_));
 
-  dotfile_input_file_.reset(new InputFile(SourceFile("//.gn")));
+  dotfile_input_file_ = std::make_unique<InputFile>(SourceFile("//.gn"));
   if (!dotfile_input_file_->Load(dotfile_name_)) {
     Err(Location(), "Could not load dotfile.",
         "The file \"" + FilePathToUTF8(dotfile_name_) + "\" couldn't be loaded")
@@ -771,7 +773,8 @@
       err.PrintToStdout();
       return false;
     }
-    std::unique_ptr<std::set<SourceFile>> whitelist(new std::set<SourceFile>);
+    std::unique_ptr<std::set<SourceFile>> whitelist =
+        std::make_unique<std::set<SourceFile>>();
     for (const auto& item : exec_script_whitelist_value->list_value()) {
       if (!item.VerifyTypeIs(Value::STRING, &err)) {
         err.PrintToStdout();
diff --git a/tools/gn/string_utils_unittest.cc b/tools/gn/string_utils_unittest.cc
index eb021a8..3e87c77 100644
--- a/tools/gn/string_utils_unittest.cc
+++ b/tools/gn/string_utils_unittest.cc
@@ -5,6 +5,8 @@
 #include "tools/gn/string_utils.h"
 
 #include <stdint.h>
+
+#include <memory>
 #include <utility>
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ -23,8 +25,8 @@
   scope.SetValue("onestring", Value(nullptr, "one"), nullptr);
 
   // Nested scope called "onescope" with a value "one" inside it.
-  std::unique_ptr<Scope> onescope(
-      new Scope(static_cast<const Settings*>(nullptr)));
+  std::unique_ptr<Scope> onescope =
+      std::make_unique<Scope>(static_cast<const Settings*>(nullptr));
   onescope->SetValue("one", Value(nullptr, one), nullptr);
   scope.SetValue("onescope", Value(nullptr, std::move(onescope)), nullptr);
 
diff --git a/tools/gn/target_generator.cc b/tools/gn/target_generator.cc
index d751115..c31e754 100644
--- a/tools/gn/target_generator.cc
+++ b/tools/gn/target_generator.cc
@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 
+#include <memory>
 #include <utility>
 
 #include "tools/gn/action_target_generator.h"
@@ -90,7 +91,8 @@
   if (g_scheduler->verbose_logging())
     g_scheduler->Log("Defining target", label.GetUserVisibleName(true));
 
-  std::unique_ptr<Target> target(new Target(scope->settings(), label));
+  std::unique_ptr<Target> target =
+      std::make_unique<Target>(scope->settings(), label);
   target->set_defined_from(function_call);
 
   // Create and call out to the proper generator.
diff --git a/tools/gn/target_unittest.cc b/tools/gn/target_unittest.cc
index 9ddcf37..bf943e8 100644
--- a/tools/gn/target_unittest.cc
+++ b/tools/gn/target_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "tools/gn/target.h"
 
+#include <memory>
 #include <utility>
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ -589,7 +590,7 @@
 
   Toolchain toolchain(setup.settings(), Label(SourceDir("//tc/"), "tc"));
 
-  std::unique_ptr<Tool> solink_tool(new Tool());
+  std::unique_ptr<Tool> solink_tool = std::make_unique<Tool>();
   solink_tool->set_output_prefix("lib");
   solink_tool->set_default_output_extension(".so");
 
@@ -630,7 +631,7 @@
 
   Toolchain toolchain(setup.settings(), Label(SourceDir("//tc/"), "tc"));
 
-  std::unique_ptr<Tool> solink_tool(new Tool());
+  std::unique_ptr<Tool> solink_tool = std::make_unique<Tool>();
   solink_tool->set_output_prefix("");
   solink_tool->set_default_output_extension(".dll");
 
diff --git a/tools/gn/template.cc b/tools/gn/template.cc
index 66d6745..0cc3131 100644
--- a/tools/gn/template.cc
+++ b/tools/gn/template.cc
@@ -4,6 +4,7 @@
 
 #include "tools/gn/template.h"
 
+#include <memory>
 #include <utility>
 
 #include "tools/gn/err.h"
@@ -38,7 +39,7 @@
 
   // First run the invocation's block. Need to allocate the scope on the heap
   // so we can pass ownership to the template.
-  std::unique_ptr<Scope> invocation_scope(new Scope(scope));
+  std::unique_ptr<Scope> invocation_scope = std::make_unique<Scope>(scope);
   if (!FillTargetBlockScope(scope, invocation, template_name,
                             block, args, invocation_scope.get(), err))
     return Value();
diff --git a/tools/gn/test_with_scope.cc b/tools/gn/test_with_scope.cc
index b239c64..d5c80c2 100644
--- a/tools/gn/test_with_scope.cc
+++ b/tools/gn/test_with_scope.cc
@@ -4,6 +4,7 @@
 
 #include "tools/gn/test_with_scope.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ -74,7 +75,7 @@
   Err err;
 
   // CC
-  std::unique_ptr<Tool> cc_tool(new Tool);
+  std::unique_ptr<Tool> cc_tool = std::make_unique<Tool>();
   SetCommandForTool(
       "cc {{source}} {{cflags}} {{cflags_c}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
@@ -84,7 +85,7 @@
   toolchain->SetTool(Toolchain::TYPE_CC, std::move(cc_tool));
 
   // CXX
-  std::unique_ptr<Tool> cxx_tool(new Tool);
+  std::unique_ptr<Tool> cxx_tool = std::make_unique<Tool>();
   SetCommandForTool(
       "c++ {{source}} {{cflags}} {{cflags_cc}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
@@ -94,7 +95,7 @@
   toolchain->SetTool(Toolchain::TYPE_CXX, std::move(cxx_tool));
 
   // OBJC
-  std::unique_ptr<Tool> objc_tool(new Tool);
+  std::unique_ptr<Tool> objc_tool = std::make_unique<Tool>();
   SetCommandForTool(
       "objcc {{source}} {{cflags}} {{cflags_objc}} {{defines}} "
       "{{include_dirs}} -o {{output}}",
@@ -104,7 +105,7 @@
   toolchain->SetTool(Toolchain::TYPE_OBJC, std::move(objc_tool));
 
   // OBJC
-  std::unique_ptr<Tool> objcxx_tool(new Tool);
+  std::unique_ptr<Tool> objcxx_tool = std::make_unique<Tool>();
   SetCommandForTool(
       "objcxx {{source}} {{cflags}} {{cflags_objcc}} {{defines}} "
       "{{include_dirs}} -o {{output}}",
@@ -116,7 +117,7 @@
   // Don't use RC and ASM tools in unit tests yet. Add here if needed.
 
   // ALINK
-  std::unique_ptr<Tool> alink_tool(new Tool);
+  std::unique_ptr<Tool> alink_tool = std::make_unique<Tool>();
   SetCommandForTool("ar {{output}} {{source}}", alink_tool.get());
   alink_tool->set_lib_switch("-l");
   alink_tool->set_lib_dir_switch("-L");
@@ -126,7 +127,7 @@
   toolchain->SetTool(Toolchain::TYPE_ALINK, std::move(alink_tool));
 
   // SOLINK
-  std::unique_ptr<Tool> solink_tool(new Tool);
+  std::unique_ptr<Tool> solink_tool = std::make_unique<Tool>();
   SetCommandForTool("ld -shared -o {{target_output_name}}.so {{inputs}} "
       "{{ldflags}} {{libs}}", solink_tool.get());
   solink_tool->set_lib_switch("-l");
@@ -138,7 +139,7 @@
   toolchain->SetTool(Toolchain::TYPE_SOLINK, std::move(solink_tool));
 
   // SOLINK_MODULE
-  std::unique_ptr<Tool> solink_module_tool(new Tool);
+  std::unique_ptr<Tool> solink_module_tool = std::make_unique<Tool>();
   SetCommandForTool("ld -bundle -o {{target_output_name}}.so {{inputs}} "
       "{{ldflags}} {{libs}}", solink_module_tool.get());
   solink_module_tool->set_lib_switch("-l");
@@ -151,7 +152,7 @@
                      std::move(solink_module_tool));
 
   // LINK
-  std::unique_ptr<Tool> link_tool(new Tool);
+  std::unique_ptr<Tool> link_tool = std::make_unique<Tool>();
   SetCommandForTool("ld -o {{target_output_name}} {{source}} "
       "{{ldflags}} {{libs}}", link_tool.get());
   link_tool->set_lib_switch("-l");
@@ -161,23 +162,23 @@
   toolchain->SetTool(Toolchain::TYPE_LINK, std::move(link_tool));
 
   // STAMP
-  std::unique_ptr<Tool> stamp_tool(new Tool);
+  std::unique_ptr<Tool> stamp_tool = std::make_unique<Tool>();
   SetCommandForTool("touch {{output}}", stamp_tool.get());
   toolchain->SetTool(Toolchain::TYPE_STAMP, std::move(stamp_tool));
 
   // COPY
-  std::unique_ptr<Tool> copy_tool(new Tool);
+  std::unique_ptr<Tool> copy_tool = std::make_unique<Tool>();
   SetCommandForTool("cp {{source}} {{output}}", copy_tool.get());
   toolchain->SetTool(Toolchain::TYPE_COPY, std::move(copy_tool));
 
   // COPY_BUNDLE_DATA
-  std::unique_ptr<Tool> copy_bundle_data_tool(new Tool);
+  std::unique_ptr<Tool> copy_bundle_data_tool = std::make_unique<Tool>();
   SetCommandForTool("cp {{source}} {{output}}", copy_bundle_data_tool.get());
   toolchain->SetTool(Toolchain::TYPE_COPY_BUNDLE_DATA,
                      std::move(copy_bundle_data_tool));
 
   // COMPILE_XCASSETS
-  std::unique_ptr<Tool> compile_xcassets_tool(new Tool);
+  std::unique_ptr<Tool> compile_xcassets_tool = std::make_unique<Tool>();
   SetCommandForTool("touch {{output}}", compile_xcassets_tool.get());
   toolchain->SetTool(Toolchain::TYPE_COMPILE_XCASSETS,
                      std::move(compile_xcassets_tool));
diff --git a/tools/gn/visibility.cc b/tools/gn/visibility.cc
index b32586c..d130caf 100644
--- a/tools/gn/visibility.cc
+++ b/tools/gn/visibility.cc
@@ -4,7 +4,8 @@
 
 #include "tools/gn/visibility.h"
 
-#include "base/memory/ptr_util.h"
+#include <memory>
+
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
@@ -86,11 +87,10 @@
 }
 
 std::unique_ptr<base::Value> Visibility::AsValue() const {
-  auto* res = new base::ListValue();
+  auto res = std::make_unique<base::ListValue>();
   for (const auto& pattern : patterns_)
     res->AppendString(pattern.Describe());
-
-  return WrapUnique(res);
+  return res;
 }
 
 // static
diff --git a/tools/gn/visual_studio_writer.cc b/tools/gn/visual_studio_writer.cc
index bbb99c6..4e56b77 100644
--- a/tools/gn/visual_studio_writer.cc
+++ b/tools/gn/visual_studio_writer.cc
@@ -397,7 +397,7 @@
   base::FilePath vcxproj_path = build_settings_->GetFullPath(target_file);
   std::string vcxproj_path_str = FilePathToUTF8(vcxproj_path);
 
-  projects_.emplace_back(new SolutionProject(
+  projects_.push_back(std::make_unique<SolutionProject>(
       project_name, vcxproj_path_str,
       MakeGuid(vcxproj_path_str, kGuidSeedProject),
       FilePathToUTF8(build_settings_->GetFullPath(target->label().dir())),
@@ -817,9 +817,9 @@
       project->parent_folder = it->second;
     } else {
       std::string folder_path_str = folder_path.as_string();
-      std::unique_ptr<SolutionEntry> folder(new SolutionEntry(
+      std::unique_ptr<SolutionEntry> folder = std::make_unique<SolutionEntry>(
           FindLastDirComponent(SourceDir(folder_path)).as_string(),
-          folder_path_str, MakeGuid(folder_path_str, kGuidSeedFolder)));
+          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));
@@ -862,10 +862,11 @@
       if (it != processed_paths.end()) {
         folder = it->second;
       } else {
-        std::unique_ptr<SolutionEntry> new_folder(new SolutionEntry(
-            FindLastDirComponent(SourceDir(parent_path)).as_string(),
-            parent_path.as_string(),
-            MakeGuid(parent_path.as_string(), kGuidSeedFolder)));
+        std::unique_ptr<SolutionEntry> new_folder =
+            std::make_unique<SolutionEntry>(
+                FindLastDirComponent(SourceDir(parent_path)).as_string(),
+                parent_path.as_string(),
+                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));
diff --git a/tools/gn/visual_studio_writer_unittest.cc b/tools/gn/visual_studio_writer_unittest.cc
index 6a7fbfc..b924182 100644
--- a/tools/gn/visual_studio_writer_unittest.cc
+++ b/tools/gn/visual_studio_writer_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "tools/gn/visual_studio_writer.h"
 
+#include <memory>
+
 #include "base/strings/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/test_with_scope.h"
@@ -33,24 +35,28 @@
 
   std::string path =
       MakeTestPath("/foo/chromium/src/out/Debug/obj/base/base.vcxproj");
-  writer.projects_.emplace_back(new VisualStudioWriter::SolutionProject(
-      "base", path, MakeGuid(path, "project"),
-      MakeTestPath("/foo/chromium/src/base"), "Win32"));
+  writer.projects_.push_back(
+      std::make_unique<VisualStudioWriter::SolutionProject>(
+          "base", path, MakeGuid(path, "project"),
+          MakeTestPath("/foo/chromium/src/base"), "Win32"));
 
   path = MakeTestPath("/foo/chromium/src/out/Debug/obj/tools/gn/gn.vcxproj");
-  writer.projects_.emplace_back(new VisualStudioWriter::SolutionProject(
-      "gn", path, MakeGuid(path, "project"),
-      MakeTestPath("/foo/chromium/src/tools/gn"), "Win32"));
+  writer.projects_.push_back(
+      std::make_unique<VisualStudioWriter::SolutionProject>(
+          "gn", path, MakeGuid(path, "project"),
+          MakeTestPath("/foo/chromium/src/tools/gn"), "Win32"));
 
   path = MakeTestPath("/foo/chromium/src/out/Debug/obj/chrome/chrome.vcxproj");
-  writer.projects_.emplace_back(new VisualStudioWriter::SolutionProject(
-      "chrome", path, MakeGuid(path, "project"),
-      MakeTestPath("/foo/chromium/src/chrome"), "Win32"));
+  writer.projects_.push_back(
+      std::make_unique<VisualStudioWriter::SolutionProject>(
+          "chrome", path, MakeGuid(path, "project"),
+          MakeTestPath("/foo/chromium/src/chrome"), "Win32"));
 
   path = MakeTestPath("/foo/chromium/src/out/Debug/obj/base/bar.vcxproj");
-  writer.projects_.emplace_back(new VisualStudioWriter::SolutionProject(
-      "bar", path, MakeGuid(path, "project"),
-      MakeTestPath("/foo/chromium/src/base"), "Win32"));
+  writer.projects_.push_back(
+      std::make_unique<VisualStudioWriter::SolutionProject>(
+          "bar", path, MakeGuid(path, "project"),
+          MakeTestPath("/foo/chromium/src/base"), "Win32"));
 
   writer.ResolveSolutionFolders();
 
@@ -88,20 +94,23 @@
 
   std::string path =
       MakeTestPath("/foo/chromium/src/out/Debug/obj/base/base.vcxproj");
-  writer.projects_.emplace_back(new VisualStudioWriter::SolutionProject(
-      "base", path, MakeGuid(path, "project"),
-      MakeTestPath("/foo/chromium/src/base"), "Win32"));
+  writer.projects_.push_back(
+      std::make_unique<VisualStudioWriter::SolutionProject>(
+          "base", path, MakeGuid(path, "project"),
+          MakeTestPath("/foo/chromium/src/base"), "Win32"));
 
   path = MakeTestPath("/foo/chromium/src/out/Debug/obj/tools/gn/gn.vcxproj");
-  writer.projects_.emplace_back(new VisualStudioWriter::SolutionProject(
-      "gn", path, MakeGuid(path, "project"),
-      MakeTestPath("/foo/chromium/src/tools/gn"), "Win32"));
+  writer.projects_.push_back(
+      std::make_unique<VisualStudioWriter::SolutionProject>(
+          "gn", path, MakeGuid(path, "project"),
+          MakeTestPath("/foo/chromium/src/tools/gn"), "Win32"));
 
   path = MakeTestPath(
       "/foo/chromium/src/out/Debug/obj/ABS_PATH/C/foo/bar/bar.vcxproj");
-  writer.projects_.emplace_back(new VisualStudioWriter::SolutionProject(
-      "bar", path, MakeGuid(path, "project"), MakeTestPath("/foo/bar"),
-      "Win32"));
+  writer.projects_.push_back(
+      std::make_unique<VisualStudioWriter::SolutionProject>(
+          "bar", path, MakeGuid(path, "project"), MakeTestPath("/foo/bar"),
+          "Win32"));
 
   std::string baz_label_dir_path = MakeTestPath("/foo/bar/baz");
 #if defined(OS_WIN)
@@ -110,8 +119,9 @@
 #endif
   path = MakeTestPath(
       "/foo/chromium/src/out/Debug/obj/ABS_PATH/C/foo/bar/baz/baz.vcxproj");
-  writer.projects_.emplace_back(new VisualStudioWriter::SolutionProject(
-      "baz", path, MakeGuid(path, "project"), baz_label_dir_path, "Win32"));
+  writer.projects_.push_back(
+      std::make_unique<VisualStudioWriter::SolutionProject>(
+          "baz", path, MakeGuid(path, "project"), baz_label_dir_path, "Win32"));
 
   writer.ResolveSolutionFolders();
 
diff --git a/tools/gn/xcode_object.cc b/tools/gn/xcode_object.cc
index 17d82e5..b229d2d 100644
--- a/tools/gn/xcode_object.cc
+++ b/tools/gn/xcode_object.cc
@@ -5,12 +5,12 @@
 #include "tools/gn/xcode_object.h"
 
 #include <iomanip>
+#include <memory>
 #include <sstream>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "tools/gn/filesystem_utils.h"
 
@@ -321,7 +321,7 @@
       name_(name) {
   if (!shell_script.empty()) {
     build_phases_.push_back(
-        base::MakeUnique<PBXShellScriptBuildPhase>(name, shell_script));
+        std::make_unique<PBXShellScriptBuildPhase>(name, shell_script));
   }
 }
 
@@ -541,7 +541,7 @@
       }
     }
 
-    children_.push_back(base::MakeUnique<PBXFileReference>(
+    children_.push_back(std::make_unique<PBXFileReference>(
         navigator_path, source_path, std::string()));
     return static_cast<PBXFileReference*>(children_.back().get());
   }
@@ -560,7 +560,7 @@
   }
 
   if (!group) {
-    children_.push_back(base::MakeUnique<PBXGroup>(component.as_string(),
+    children_.push_back(std::make_unique<PBXGroup>(component.as_string(),
                                                    component.as_string()));
     group = static_cast<PBXGroup*>(children_.back().get());
   }
@@ -617,11 +617,11 @@
       product_type_(product_type),
       product_name_(product_name) {
   DCHECK(product_reference_);
-  build_phases_.push_back(base::MakeUnique<PBXSourcesBuildPhase>());
+  build_phases_.push_back(std::make_unique<PBXSourcesBuildPhase>());
   source_build_phase_ =
       static_cast<PBXSourcesBuildPhase*>(build_phases_.back().get());
 
-  build_phases_.push_back(base::MakeUnique<PBXFrameworksBuildPhase>());
+  build_phases_.push_back(std::make_unique<PBXFrameworksBuildPhase>());
 }
 
 PBXNativeTarget::~PBXNativeTarget() {}
@@ -629,7 +629,7 @@
 void PBXNativeTarget::AddFileForIndexing(const PBXFileReference* file_reference,
                                          const CompilerFlags compiler_flag) {
   DCHECK(file_reference);
-  source_build_phase_->AddBuildFile(base::MakeUnique<PBXBuildFile>(
+  source_build_phase_->AddBuildFile(std::make_unique<PBXBuildFile>(
       file_reference, source_build_phase_, compiler_flag));
 }
 
@@ -664,11 +664,11 @@
 
   main_group_.reset(new PBXGroup);
   sources_ = static_cast<PBXGroup*>(
-      main_group_->AddChild(base::MakeUnique<PBXGroup>(source_path, "Source")));
+      main_group_->AddChild(std::make_unique<PBXGroup>(source_path, "Source")));
   sources_->set_is_source(true);
   products_ = static_cast<PBXGroup*>(main_group_->AddChild(
-      base::MakeUnique<PBXGroup>(std::string(), "Product")));
-  main_group_->AddChild(base::MakeUnique<PBXGroup>(std::string(), "Build"));
+      std::make_unique<PBXGroup>(std::string(), "Product")));
+  main_group_->AddChild(std::make_unique<PBXGroup>(std::string(), "Build"));
 
   configurations_.reset(new XCConfigurationList(config_name, attributes, this));
 }
@@ -707,7 +707,7 @@
   attributes["CONFIGURATION_BUILD_DIR"] = ".";
   attributes["PRODUCT_NAME"] = name;
 
-  targets_.push_back(base::MakeUnique<PBXAggregateTarget>(
+  targets_.push_back(std::make_unique<PBXAggregateTarget>(
       name, shell_script, config_name_, attributes));
 }
 
@@ -719,11 +719,11 @@
   attributes["PRODUCT_NAME"] = "sources";
 
   PBXFileReference* product_reference = static_cast<PBXFileReference*>(
-      products_->AddChild(base::MakeUnique<PBXFileReference>(
+      products_->AddChild(std::make_unique<PBXFileReference>(
           std::string(), "sources", "compiled.mach-o.executable")));
 
   const char product_type[] = "com.apple.product-type.tool";
-  targets_.push_back(base::MakeUnique<PBXNativeTarget>(
+  targets_.push_back(std::make_unique<PBXNativeTarget>(
       "sources", std::string(), config_name_, attributes, product_type,
       "sources", product_reference));
   target_for_indexing_ = static_cast<PBXNativeTarget*>(targets_.back().get());
@@ -738,7 +738,7 @@
     const PBXAttributes& extra_attributes) {
   base::StringPiece ext = FindExtension(&output_name);
   PBXFileReference* product = static_cast<PBXFileReference*>(
-      products_->AddChild(base::MakeUnique<PBXFileReference>(
+      products_->AddChild(std::make_unique<PBXFileReference>(
           std::string(), output_name,
           type.empty() ? GetSourceType(ext) : type)));
 
@@ -760,7 +760,7 @@
   attributes["CONFIGURATION_BUILD_DIR"] = ".";
   attributes["PRODUCT_NAME"] = product_name;
 
-  targets_.push_back(base::MakeUnique<PBXNativeTarget>(
+  targets_.push_back(std::make_unique<PBXNativeTarget>(
       name, shell_script, config_name_, attributes, output_type, product_name,
       product));
   return static_cast<PBXNativeTarget*>(targets_.back().get());
@@ -953,7 +953,7 @@
     : owner_reference_(owner_reference) {
   DCHECK(owner_reference_);
   configurations_.push_back(
-      base::MakeUnique<XCBuildConfiguration>(name, attributes));
+      std::make_unique<XCBuildConfiguration>(name, attributes));
 }
 
 XCConfigurationList::~XCConfigurationList() {}
diff --git a/tools/gn/xcode_object_unittest.cc b/tools/gn/xcode_object_unittest.cc
index 52a98b9..656d0b7 100644
--- a/tools/gn/xcode_object_unittest.cc
+++ b/tools/gn/xcode_object_unittest.cc
@@ -4,7 +4,6 @@
 
 #include "tools/gn/xcode_object.h"
 
-#include "base/memory/ptr_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
@@ -306,22 +305,23 @@
 
 // Tests the mapping between PBXObjectClass and it's name as a string.
 TEST(XcodeObject, ClassToString) {
-  EXPECT_EQ("PBXAggregateTarget", ToString(PBXAggregateTargetClass));
-  EXPECT_EQ("PBXBuildFile", ToString(PBXBuildFileClass));
-  EXPECT_EQ("PBXAggregateTarget", ToString(PBXAggregateTargetClass));
-  EXPECT_EQ("PBXBuildFile", ToString(PBXBuildFileClass));
-  EXPECT_EQ("PBXContainerItemProxy", ToString(PBXContainerItemProxyClass));
-  EXPECT_EQ("PBXFileReference", ToString(PBXFileReferenceClass));
-  EXPECT_EQ("PBXFrameworksBuildPhase", ToString(PBXFrameworksBuildPhaseClass));
-  EXPECT_EQ("PBXGroup", ToString(PBXGroupClass));
-  EXPECT_EQ("PBXNativeTarget", ToString(PBXNativeTargetClass));
-  EXPECT_EQ("PBXProject", ToString(PBXProjectClass));
-  EXPECT_EQ("PBXSourcesBuildPhase", ToString(PBXSourcesBuildPhaseClass));
-  EXPECT_EQ("PBXTargetDependency", ToString(PBXTargetDependencyClass));
-  EXPECT_EQ("XCBuildConfiguration", ToString(XCBuildConfigurationClass));
-  EXPECT_EQ("XCConfigurationList", ToString(XCConfigurationListClass));
-  EXPECT_EQ("PBXShellScriptBuildPhase",
-            ToString(PBXShellScriptBuildPhaseClass));
+  EXPECT_STREQ("PBXAggregateTarget", ToString(PBXAggregateTargetClass));
+  EXPECT_STREQ("PBXBuildFile", ToString(PBXBuildFileClass));
+  EXPECT_STREQ("PBXAggregateTarget", ToString(PBXAggregateTargetClass));
+  EXPECT_STREQ("PBXBuildFile", ToString(PBXBuildFileClass));
+  EXPECT_STREQ("PBXContainerItemProxy", ToString(PBXContainerItemProxyClass));
+  EXPECT_STREQ("PBXFileReference", ToString(PBXFileReferenceClass));
+  EXPECT_STREQ("PBXFrameworksBuildPhase",
+               ToString(PBXFrameworksBuildPhaseClass));
+  EXPECT_STREQ("PBXGroup", ToString(PBXGroupClass));
+  EXPECT_STREQ("PBXNativeTarget", ToString(PBXNativeTargetClass));
+  EXPECT_STREQ("PBXProject", ToString(PBXProjectClass));
+  EXPECT_STREQ("PBXSourcesBuildPhase", ToString(PBXSourcesBuildPhaseClass));
+  EXPECT_STREQ("PBXTargetDependency", ToString(PBXTargetDependencyClass));
+  EXPECT_STREQ("XCBuildConfiguration", ToString(XCBuildConfigurationClass));
+  EXPECT_STREQ("XCConfigurationList", ToString(XCConfigurationListClass));
+  EXPECT_STREQ("PBXShellScriptBuildPhase",
+               ToString(PBXShellScriptBuildPhaseClass));
 }
 
 // Tests the mapping between PBXObject and it's name as a string.
diff --git a/tools/gn/xcode_writer.cc b/tools/gn/xcode_writer.cc
index c10ebb4..3134b48 100644
--- a/tools/gn/xcode_writer.cc
+++ b/tools/gn/xcode_writer.cc
@@ -13,7 +13,6 @@
 
 #include "base/environment.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ -151,8 +150,8 @@
                             PBXTarget* dependent_pbxtarget,
                             const PBXProject* project) {
   auto container_item_proxy =
-      base::MakeUnique<PBXContainerItemProxy>(project, base_pbxtarget);
-  auto dependency = base::MakeUnique<PBXTargetDependency>(
+      std::make_unique<PBXContainerItemProxy>(project, base_pbxtarget);
+  auto dependency = std::make_unique<PBXTargetDependency>(
       base_pbxtarget, std::move(container_item_proxy));
 
   dependent_pbxtarget->AddDependency(std::move(dependency));
diff --git a/tools/gn/xml_element_writer.cc b/tools/gn/xml_element_writer.cc
index ecc4f7b..127766c 100644
--- a/tools/gn/xml_element_writer.cc
+++ b/tools/gn/xml_element_writer.cc
@@ -4,7 +4,7 @@
 
 #include "tools/gn/xml_element_writer.h"
 
-#include "base/memory/ptr_util.h"
+#include <memory>
 
 XmlAttributes::XmlAttributes() {}
 
@@ -64,7 +64,7 @@
     const std::string& tag,
     const XmlAttributes& attributes) {
   StartContent(true);
-  return base::MakeUnique<XmlElementWriter>(out_, tag, attributes, indent_ + 2);
+  return std::make_unique<XmlElementWriter>(out_, tag, attributes, indent_ + 2);
 }
 
 std::ostream& XmlElementWriter::StartContent(bool start_new_line) {
diff --git a/tools/gn/xml_element_writer.h b/tools/gn/xml_element_writer.h
index 0e8fa01..4aa5f7e 100644
--- a/tools/gn/xml_element_writer.h
+++ b/tools/gn/xml_element_writer.h
@@ -12,7 +12,6 @@
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_piece.h"
 
 // Vector of XML attribute key-value pairs.
@@ -116,7 +115,7 @@
     const std::string& attribute_name,
     const Writer& attribute_value_writer) {
   StartContent(true);
-  return base::MakeUnique<XmlElementWriter>(
+  return std::make_unique<XmlElementWriter>(
       out_, tag, attribute_name, attribute_value_writer, indent_ + 2);
 }