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

tools/gn/desc_builder.cc

 // Copyright (c) 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 <set>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/config.h"
@@ skipping 96 matching lines @@
 
  protected:
   virtual Label GetToolchainLabel() const = 0;
 
   bool what(const std::string& w) const {
     return what_.empty() || what_.find(w) != what_.end();
   }
 
   template <typename T>
   ValuePtr RenderValue(const std::vector<T>& vector) {
-    auto res = base::WrapUnique(new base::ListValue());
+    auto res = base::MakeUnique<base::ListValue>();
     for (const auto& v : vector)
       res->Append(RenderValue(v));
 
     return std::move(res);
   }
 
   ValuePtr RenderValue(const std::string& s, bool optional = false) {
     return (s.empty() && optional) ? base::Value::CreateNullValue()
                                    : ValuePtr(new base::StringValue(s));
   }
@@ skipping 46 matching lines @@
   bool tree_;
   bool blame_;
 };
 
 class ConfigDescBuilder : public BaseDescBuilder {
  public:
   ConfigDescBuilder(const Config* config, const std::set<std::string>& what)
       : BaseDescBuilder(what, false, false, false), config_(config) {}
 
   std::unique_ptr<base::DictionaryValue> BuildDescription() {
-    auto res = base::WrapUnique(new base::DictionaryValue());
+    auto res = base::MakeUnique<base::DictionaryValue>();
     const ConfigValues& values = config_->resolved_values();
 
     if (what_.empty())
       res->SetString(
           "toolchain",
           config_->label().GetToolchainLabel().GetUserVisibleName(false));
 
     if (what(variables::kConfigs) && !config_->configs().empty()) {
-      auto configs = base::WrapUnique(new base::ListValue());
+      auto configs = base::MakeUnique<base::ListValue>();
       FillInConfigVector(configs.get(), config_->configs().vector());
       res->Set(variables::kConfigs, std::move(configs));
     }
 
 #define CONFIG_VALUE_ARRAY_HANDLER(name, type)                        \
   if (what(#name)) {                                                  \
     ValuePtr ptr =                                                    \
         render_config_value_array<type>(values, &ConfigValues::name); \
     if (ptr) {                                                        \
       res->Set(#name, std::move(ptr));                                \
@@ skipping 22 matching lines @@
  protected:
   Label GetToolchainLabel() const override {
     return config_->label().GetToolchainLabel();
   }
 
  private:
   template <typename T>
   ValuePtr render_config_value_array(
       const ConfigValues& values,
       const std::vector<T>& (ConfigValues::*getter)() const) {
-    auto res = base::WrapUnique(new base::ListValue());
+    auto res = base::MakeUnique<base::ListValue>();
 
     for (const T& cur : (values.*getter)())
       res->Append(RenderValue(cur));
 
     return res->empty() ? nullptr : std::move(res);
   }
 
   const Config* config_;
 };
 
 class TargetDescBuilder : public BaseDescBuilder {
  public:
   TargetDescBuilder(const Target* target,
                     const std::set<std::string>& what,
                     bool all,
                     bool tree,
                     bool blame)
       : BaseDescBuilder(what, all, tree, blame), target_(target) {}
 
   std::unique_ptr<base::DictionaryValue> BuildDescription() {
-    auto res = base::WrapUnique(new base::DictionaryValue());
+    auto res = base::MakeUnique<base::DictionaryValue>();
     bool is_binary_output = target_->IsBinary();
 
     if (what_.empty()) {
       res->SetString("type",
                      Target::GetStringForOutputType(target_->output_type()));
       res->SetString(
           "toolchain",
           target_->label().GetToolchainLabel().GetUserVisibleName(false));
     }
 
     // General target meta variables.
     if (what(variables::kVisibility))
       res->Set(variables::kVisibility, target_->visibility().AsValue());
 
     if (what(variables::kTestonly))
       res->SetBoolean(variables::kTestonly, target_->testonly());
 
     if (is_binary_output) {
       if (what(variables::kCheckIncludes))
         res->SetBoolean(variables::kCheckIncludes, target_->check_includes());
 
       if (what(variables::kAllowCircularIncludesFrom)) {
-        auto labels = base::WrapUnique(new base::ListValue());
+        auto labels = base::MakeUnique<base::ListValue>();
         for (const auto& cur : target_->allow_circular_includes_from())
           labels->AppendString(cur.GetUserVisibleName(GetToolchainLabel()));
 
         res->Set(variables::kAllowCircularIncludesFrom, std::move(labels));
       }
     }
 
     if (what(variables::kSources) && !target_->sources().empty())
       res->Set(variables::kSources, RenderValue(target_->sources()));
 
@@ skipping 11 matching lines @@
         res->SetString(variables::kPublic, "*");
       else
         res->Set(variables::kPublic, RenderValue(target_->public_headers()));
     }
 
     if (what(variables::kInputs) && !target_->inputs().empty())
       res->Set(variables::kInputs, RenderValue(target_->inputs()));
 
     if (is_binary_output && what(variables::kConfigs) &&
         !target_->configs().empty()) {
-      auto configs = base::WrapUnique(new base::ListValue());
+      auto configs = base::MakeUnique<base::ListValue>();
       FillInConfigVector(configs.get(), target_->configs().vector());
       res->Set(variables::kConfigs, std::move(configs));
     }
 
     if (what(variables::kPublicConfigs) && !target_->public_configs().empty()) {
-      auto configs = base::WrapUnique(new base::ListValue());
+      auto configs = base::MakeUnique<base::ListValue>();
       FillInConfigVector(configs.get(), target_->public_configs());
       res->Set(variables::kPublicConfigs, std::move(configs));
     }
 
     if (what(variables::kAllDependentConfigs) &&
         !target_->all_dependent_configs().empty()) {
-      auto configs = base::WrapUnique(new base::ListValue());
+      auto configs = base::MakeUnique<base::ListValue>();
       FillInConfigVector(configs.get(), target_->all_dependent_configs());
       res->Set(variables::kAllDependentConfigs, std::move(configs));
     }
 
     // Action
     if (target_->output_type() == Target::ACTION ||
         target_->output_type() == Target::ACTION_FOREACH) {
       if (what(variables::kScript))
         res->SetString(variables::kScript,
                        target_->action_values().script().value());
 
       if (what(variables::kArgs)) {
-        auto args = base::WrapUnique(new base::ListValue());
+        auto args = base::MakeUnique<base::ListValue>();
         for (const auto& elem : target_->action_values().args().list())
           args->AppendString(elem.AsString());
 
         res->Set(variables::kArgs, std::move(args));
       }
       if (what(variables::kDepfile) &&
           !target_->action_values().depfile().empty()) {
         res->SetString(variables::kDepfile,
                        target_->action_values().depfile().AsString());
       }
@@ skipping 49 matching lines @@
     // libs and lib_dirs are special in that they're inherited. We don't
     // currently
     // implement a blame feature for this since the bottom-up inheritance makes
     // this difficult.
 
     // Libs can be part of any target and get recursively pushed up the chain,
     // so display them regardless of target type.
     if (what(variables::kLibs)) {
       const OrderedSet<LibFile>& all_libs = target_->all_libs();
       if (!all_libs.empty()) {
-        auto libs = base::WrapUnique(new base::ListValue());
+        auto libs = base::MakeUnique<base::ListValue>();
         for (size_t i = 0; i < all_libs.size(); i++)
           libs->AppendString(all_libs[i].value());
         res->Set(variables::kLibs, std::move(libs));
       }
     }
 
     if (what(variables::kLibDirs)) {
       const OrderedSet<SourceDir>& all_lib_dirs = target_->all_lib_dirs();
       if (!all_lib_dirs.empty()) {
-        auto lib_dirs = base::WrapUnique(new base::ListValue());
+        auto lib_dirs = base::MakeUnique<base::ListValue>();
         for (size_t i = 0; i < all_lib_dirs.size(); i++)
           lib_dirs->AppendString(FormatSourceDir(all_lib_dirs[i]));
         res->Set(variables::kLibDirs, std::move(lib_dirs));
       }
     }
 
     return res;
   }
 
  private:
@@ skipping 36 matching lines @@
       }
 
       out->AppendString(str);
 
       if (print_children)
         RecursivePrintDeps(out, cur_dep, seen_targets, indent_level + 1);
     }
   }
 
   ValuePtr RenderDeps() {
-    auto res = base::WrapUnique(new base::ListValue());
+    auto res = base::MakeUnique<base::ListValue>();
 
     // Tree mode is separate.
     if (tree_) {
       if (all_) {
         // Show all tree deps with no eliding.
         RecursivePrintDeps(res.get(), target_, nullptr, 0);
       } else {
         // Don't recurse into duplicates.
         std::set<const Target*> seen_targets;
         RecursivePrintDeps(res.get(), target_, &seen_targets, 0);
@@ skipping 13 matching lines @@
           deps.push_back(pair.ptr);
         std::sort(deps.begin(), deps.end());
         commands::FilterAndPrintTargets(&deps, res.get());
       }
     }
 
     return std::move(res);
   }
 
   ValuePtr RenderRuntimeDeps() {
-    auto res = base::WrapUnique(new base::ListValue());
+    auto res = base::MakeUnique<base::ListValue>();
 
     const Target* previous_from = NULL;
     for (const auto& pair : ComputeRuntimeDeps(target_)) {
       std::string str;
       if (blame_) {
         // Generally a target's runtime deps will be listed sequentially, so
         // group them and don't duplicate the "from" label for two in a row.
         if (previous_from == pair.second) {
           str = "  ";
         } else {
           previous_from = pair.second;
           res->AppendString(
               str + "From " +
               pair.second->label().GetUserVisibleName(GetToolchainLabel()));
           str = "  ";
         }
       }
 
       res->AppendString(str + pair.first.value());
     }
 
     return std::move(res);
   }
 
   void FillInSourceOutputs(base::DictionaryValue* res) {
-    auto dict = base::WrapUnique(new base::DictionaryValue());
+    auto dict = base::MakeUnique<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::WrapUnique(new base::ListValue());
+        auto list = base::MakeUnique<base::ListValue>();
         for (const auto& output : outputs)
           list->AppendString(output.value());
 
         dict->SetWithoutPathExpansion(source.value(), std::move(list));
       }
     }
     res->Set("source_outputs", std::move(dict));
   }
 
   void FillInBundle(base::DictionaryValue* res) {
-    auto data = base::WrapUnique(new base::DictionaryValue());
+    auto data = base::MakeUnique<base::DictionaryValue>();
     const BundleData& bundle_data = target_->bundle_data();
     const Settings* settings = target_->settings();
     BundleData::SourceFiles sources;
     bundle_data.GetSourceFiles(&sources);
     data->Set("source_files", RenderValue(sources));
     data->SetString("root_dir_output",
                     bundle_data.GetBundleRootDirOutput(settings).value());
     data->Set("root_dir", RenderValue(bundle_data.root_dir()));
     data->Set("resources_dir", RenderValue(bundle_data.resources_dir()));
     data->Set("executable_dir", RenderValue(bundle_data.executable_dir()));
     data->Set("plugins_dir", RenderValue(bundle_data.plugins_dir()));
     data->SetString("product_type", bundle_data.product_type());
 
-    auto deps = base::WrapUnique(new base::ListValue());
+    auto deps = base::MakeUnique<base::ListValue>();
     for (const auto* dep : bundle_data.bundle_deps())
       deps->AppendString(dep->label().GetUserVisibleName(GetToolchainLabel()));
 
     data->Set("deps", std::move(deps));
     res->Set("bundle_data", std::move(data));
   }
 
   void FillInOutputs(base::DictionaryValue* res) {
     if (target_->output_type() == Target::ACTION) {
-      auto list = base::WrapUnique(new base::ListValue());
+      auto list = base::MakeUnique<base::ListValue>();
       for (const auto& elem : target_->action_values().outputs().list())
         list->AppendString(elem.AsString());
 
       res->Set(variables::kOutputs, std::move(list));
     } else if (target_->output_type() == Target::CREATE_BUNDLE) {
       std::vector<SourceFile> output_files;
       target_->bundle_data().GetOutputsAsSourceFiles(target_->settings(),
                                                      &output_files);
       res->Set(variables::kOutputs, RenderValue(output_files));
     } else if (target_->output_type() == Target::ACTION_FOREACH ||
                target_->output_type() == Target::COPY_FILES) {
       const SubstitutionList& outputs = target_->action_values().outputs();
       if (!outputs.required_types().empty()) {
-        auto patterns = base::WrapUnique(new base::ListValue());
+        auto patterns = base::MakeUnique<base::ListValue>();
         for (const auto& elem : outputs.list())
           patterns->AppendString(elem.AsString());
 
         res->Set("output_patterns", std::move(patterns));
       }
       std::vector<SourceFile> output_files;
       SubstitutionWriter::ApplyListToSources(target_->settings(), outputs,
                                              target_->sources(), &output_files);
       res->Set(variables::kOutputs, RenderValue(output_files));
     } else {
@@ skipping 12 matching lines @@
       res->Set(variables::kOutputs, RenderValue(output_files_as_source_file));
     }
   }
 
   // Writes a given config value type to the string, optionally with
   // attribution.
   // This should match RecursiveTargetConfigToStream in the order it traverses.
   template <class T>
   ValuePtr RenderConfigValues(const std::vector<T>& (ConfigValues::*getter)()
                                   const) {
-    auto res = base::WrapUnique(new base::ListValue());
+    auto res = base::MakeUnique<base::ListValue>();
     for (ConfigValuesIterator iter(target_); !iter.done(); iter.Next()) {
       const std::vector<T>& vec = (iter.cur().*getter)();
 
       if (vec.empty())
         continue;
 
       if (blame_) {
         const Config* config = iter.GetCurrentConfig();
         if (config) {
           // Source of this value is a config.
@@ skipping 13 matching lines @@
           res->AppendString(from);
         }
       }
 
       for (const T& val : vec) {
         ValuePtr rendered = RenderValue(val);
         std::string str;
         // Indent string values in blame mode
         if (blame_ && rendered->GetAsString(&str)) {
           str = "  " + str;
-          rendered = base::WrapUnique(new base::StringValue(str));
+          rendered = base::MakeUnique<base::StringValue>(str);
         }
         res->Append(std::move(rendered));
       }
     }
     return res->empty() ? nullptr : std::move(res);
   }
 
   Label GetToolchainLabel() const override {
     return target_->label().GetToolchainLabel();
   }
@@ skipping 18 matching lines @@
 
 std::unique_ptr<base::DictionaryValue> DescBuilder::DescriptionForConfig(
     const Config* config,
     const std::string& what) {
   std::set<std::string> w;
   if (!what.empty())
     w.insert(what);
   ConfigDescBuilder b(config, w);
   return b.BuildDescription();
 }