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

chrome/browser/prefs/command_line_pref_store.cc

 // Copyright (c) 2012 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 "chrome/browser/prefs/command_line_pref_store.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 97 matching lines @@
     return false;
   }
   return true;
 }
 
 void CommandLinePrefStore::ApplySimpleSwitches() {
   // Look for each switch we know about and set its preference accordingly.
   for (size_t i = 0; i < arraysize(string_switch_map_); ++i) {
     if (command_line_->HasSwitch(string_switch_map_[i].switch_name)) {
       SetValue(string_switch_map_[i].preference_path,
-               base::WrapUnique(
-                   new base::StringValue(command_line_->GetSwitchValueASCII(
-                       string_switch_map_[i].switch_name))),
+               base::MakeUnique<base::StringValue>(
+                   command_line_->GetSwitchValueASCII(
+                       string_switch_map_[i].switch_name)),
                WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     }
   }
 
   for (size_t i = 0; i < arraysize(path_switch_map_); ++i) {
     if (command_line_->HasSwitch(path_switch_map_[i].switch_name)) {
       SetValue(
           path_switch_map_[i].preference_path,
-          base::WrapUnique(new base::StringValue(
+          base::MakeUnique<base::StringValue>(
               command_line_->GetSwitchValuePath(path_switch_map_[i].switch_name)
-                  .value())),
+                  .value()),
           WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     }
   }
 
   for (size_t i = 0; i < arraysize(integer_switch_map_); ++i) {
     if (command_line_->HasSwitch(integer_switch_map_[i].switch_name)) {
       std::string str_value = command_line_->GetSwitchValueASCII(
           integer_switch_map_[i].switch_name);
       int int_value = 0;
       if (!base::StringToInt(str_value, &int_value)) {
         LOG(ERROR) << "The value " << str_value << " of "
                    << integer_switch_map_[i].switch_name
                    << " can not be converted to integer, ignoring!";
         continue;
       }
       SetValue(integer_switch_map_[i].preference_path,
-               base::WrapUnique(new base::FundamentalValue(int_value)),
+               base::MakeUnique<base::FundamentalValue>(int_value),
                WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     }
   }
 
   for (size_t i = 0; i < arraysize(boolean_switch_map_); ++i) {
     if (command_line_->HasSwitch(boolean_switch_map_[i].switch_name)) {
       SetValue(boolean_switch_map_[i].preference_path,
-               base::WrapUnique(new base::FundamentalValue(
-                   boolean_switch_map_[i].set_value)),
+               base::MakeUnique<base::FundamentalValue>(
+                   boolean_switch_map_[i].set_value),
                WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
     }
   }
 }
 
 void CommandLinePrefStore::ApplyProxyMode() {
   if (command_line_->HasSwitch(switches::kNoProxyServer)) {
     SetValue(proxy_config::prefs::kProxy,
              base::WrapUnique(ProxyConfigDictionary::CreateDirect()),
              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
@@ skipping 27 matching lines @@
         command_line_->GetSwitchValueASCII(switches::kCipherSuiteBlacklist),
         ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL));
     SetValue(ssl_config::prefs::kCipherSuiteBlacklist, std::move(list_value),
              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   }
 }
 
 void CommandLinePrefStore::ApplyBackgroundModeSwitches() {
   if (command_line_->HasSwitch(switches::kDisableExtensions)) {
     SetValue(prefs::kBackgroundModeEnabled,
-             base::WrapUnique(new base::FundamentalValue(false)),
+             base::MakeUnique<base::FundamentalValue>(false),
              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   }
 }