Remove raw DictionaryValue::Set in //chrome

chrome/browser/extensions/api/proxy/proxy_api_helpers.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.
 
 // Implementation of helper functions for the Chrome Extensions Proxy Settings
 // API.
 //
 // Throughout this code, we report errors to the user by setting an |error|
 // parameter, if and only if these errors can be cause by invalid input
 // from the extension and we cannot expect that the extensions API has
 // caught this error before. In all other cases we are dealing with internal
 // errors and log to LOG(ERROR).
 
 #include "chrome/browser/extensions/api/proxy/proxy_api_helpers.h"
 
 #include <stddef.h>
 
+#include <utility>
+
 #include "base/base64.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/proxy/proxy_api_constants.h"
 #include "components/proxy_config/proxy_config_dictionary.h"
 #include "extensions/common/error_utils.h"
 #include "net/base/data_url.h"
 #include "net/proxy/proxy_config.h"
 
@@ skipping 323 matching lines @@
     }
     case ProxyPrefs::MODE_SYSTEM:
       result_proxy_config = ProxyConfigDictionary::CreateSystem();
       break;
     case ProxyPrefs::kModeCount:
       NOTREACHED();
   }
   return result_proxy_config;
 }
 
-base::DictionaryValue* CreateProxyRulesDict(
+std::unique_ptr<base::DictionaryValue> CreateProxyRulesDict(
     const ProxyConfigDictionary& proxy_config) {
   ProxyPrefs::ProxyMode mode;
   CHECK(proxy_config.GetMode(&mode) && mode == ProxyPrefs::MODE_FIXED_SERVERS);
 
-  std::unique_ptr<base::DictionaryValue> extension_proxy_rules(
-      new base::DictionaryValue);
+  auto extension_proxy_rules = base::MakeUnique<base::DictionaryValue>();
 
   std::string proxy_servers;
   if (!proxy_config.GetProxyServer(&proxy_servers)) {
     LOG(ERROR) << "Missing proxy servers in configuration.";
     return NULL;
   }
 
   net::ProxyConfig::ProxyRules rules;
   rules.ParseFromString(proxy_servers);
 
@@ skipping 35 matching lines @@
   // representing this scheme in the code above.
   static_assert(keys::SCHEME_MAX == 4,
                 "rules need to be updated along with schemes");
 
   if (proxy_config.HasBypassList()) {
     std::string bypass_list_string;
     if (!proxy_config.GetBypassList(&bypass_list_string)) {
       LOG(ERROR) << "Invalid bypassList in configuration.";
       return NULL;
     }
-    base::ListValue* bypass_list =
+    std::unique_ptr<base::ListValue> bypass_list =
         TokenizeToStringList(bypass_list_string, ",;");
-    extension_proxy_rules->Set(keys::kProxyConfigBypassList, bypass_list);
+    extension_proxy_rules->Set(keys::kProxyConfigBypassList,
+                               std::move(bypass_list));
   }
 
-  return extension_proxy_rules.release();
+  return extension_proxy_rules;
 }
 
-base::DictionaryValue* CreateProxyServerDict(const net::ProxyServer& proxy) {
-  std::unique_ptr<base::DictionaryValue> out(new base::DictionaryValue);
+std::unique_ptr<base::DictionaryValue> CreateProxyServerDict(
+    const net::ProxyServer& proxy) {
+  auto out = base::MakeUnique<base::DictionaryValue>();
   switch (proxy.scheme()) {
     case net::ProxyServer::SCHEME_HTTP:
       out->SetString(keys::kProxyConfigRuleScheme, "http");
       break;
     case net::ProxyServer::SCHEME_HTTPS:
       out->SetString(keys::kProxyConfigRuleScheme, "https");
       break;
     case net::ProxyServer::SCHEME_QUIC:
       out->SetString(keys::kProxyConfigRuleScheme, "quic");
       break;
     case net::ProxyServer::SCHEME_SOCKS4:
       out->SetString(keys::kProxyConfigRuleScheme, "socks4");
       break;
     case net::ProxyServer::SCHEME_SOCKS5:
       out->SetString(keys::kProxyConfigRuleScheme, "socks5");
       break;
     case net::ProxyServer::SCHEME_DIRECT:
     case net::ProxyServer::SCHEME_INVALID:
       NOTREACHED();
       return NULL;
   }
   out->SetString(keys::kProxyConfigRuleHost, proxy.host_port_pair().host());
   out->SetInteger(keys::kProxyConfigRulePort, proxy.host_port_pair().port());
-  return out.release();
+  return out;
 }
 
-base::DictionaryValue* CreatePacScriptDict(
+std::unique_ptr<base::DictionaryValue> CreatePacScriptDict(
     const ProxyConfigDictionary& proxy_config) {
   ProxyPrefs::ProxyMode mode;
   CHECK(proxy_config.GetMode(&mode) && mode == ProxyPrefs::MODE_PAC_SCRIPT);
 
-  std::unique_ptr<base::DictionaryValue> pac_script_dict(
-      new base::DictionaryValue);
+  auto pac_script_dict = base::MakeUnique<base::DictionaryValue>();
   std::string pac_url;
   if (!proxy_config.GetPacUrl(&pac_url)) {
     LOG(ERROR) << "Invalid proxy configuration. Missing PAC URL.";
     return NULL;
   }
   bool pac_mandatory = false;
   if (!proxy_config.GetPacMandatory(&pac_mandatory)) {
     LOG(ERROR) << "Invalid proxy configuration. Missing PAC mandatory field.";
     return NULL;
   }
 
   if (base::StartsWith(pac_url, "data", base::CompareCase::SENSITIVE)) {
     std::string pac_data;
     if (!CreatePACScriptFromDataURL(pac_url, &pac_data)) {
       LOG(ERROR) << "Cannot decode base64-encoded PAC data URL: " << pac_url;
       return NULL;
     }
     pac_script_dict->SetString(keys::kProxyConfigPacScriptData, pac_data);
   } else {
     pac_script_dict->SetString(keys::kProxyConfigPacScriptUrl, pac_url);
   }
   pac_script_dict->SetBoolean(keys::kProxyConfigPacScriptMandatory,
                               pac_mandatory);
-  return pac_script_dict.release();
+  return pac_script_dict;
 }
 
-base::ListValue* TokenizeToStringList(const std::string& in,
-                                const std::string& delims) {
-  base::ListValue* out = new base::ListValue;
+std::unique_ptr<base::ListValue> TokenizeToStringList(
+    const std::string& in,
+    const std::string& delims) {
+  auto out = base::MakeUnique<base::ListValue>();
   base::StringTokenizer entries(in, delims);
   while (entries.GetNext())
     out->AppendString(entries.token());
   return out;
 }
 
 }  // namespace proxy_api_helpers
 }  // namespace extensions