Use unique_ptr<DictionaryValue> in ProxyConfigDictionary

chromeos/network/onc/onc_utils.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 "chromeos/network/onc/onc_utils.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/base64.h"
@@ skipping 906 matching lines @@
 
 }  // namespace
 
 std::unique_ptr<base::DictionaryValue> ConvertOncProxySettingsToProxyConfig(
     const base::DictionaryValue& onc_proxy_settings) {
   std::string type;
   onc_proxy_settings.GetStringWithoutPathExpansion(::onc::proxy::kType, &type);
   std::unique_ptr<base::DictionaryValue> proxy_dict;
 
   if (type == ::onc::proxy::kDirect) {
-    proxy_dict.reset(ProxyConfigDictionary::CreateDirect());
+    proxy_dict = ProxyConfigDictionary::CreateDirect();
   } else if (type == ::onc::proxy::kWPAD) {
-    proxy_dict.reset(ProxyConfigDictionary::CreateAutoDetect());
+    proxy_dict = ProxyConfigDictionary::CreateAutoDetect();
   } else if (type == ::onc::proxy::kPAC) {
     std::string pac_url;
     onc_proxy_settings.GetStringWithoutPathExpansion(::onc::proxy::kPAC,
                                                      &pac_url);
     GURL url(url_formatter::FixupURL(pac_url, std::string()));
-    proxy_dict.reset(ProxyConfigDictionary::CreatePacScript(
-        url.is_valid() ? url.spec() : std::string(), false));
+    proxy_dict = ProxyConfigDictionary::CreatePacScript(
+        url.is_valid() ? url.spec() : std::string(), false);
   } else if (type == ::onc::proxy::kManual) {
     const base::DictionaryValue* manual_dict = nullptr;
     onc_proxy_settings.GetDictionaryWithoutPathExpansion(::onc::proxy::kManual,
                                                          &manual_dict);
     std::string manual_spec;
     AppendProxyServerForScheme(*manual_dict, ::onc::proxy::kFtp, &manual_spec);
     AppendProxyServerForScheme(*manual_dict, ::onc::proxy::kHttp, &manual_spec);
     AppendProxyServerForScheme(*manual_dict, ::onc::proxy::kSocks,
                                &manual_spec);
     AppendProxyServerForScheme(*manual_dict, ::onc::proxy::kHttps,
                                &manual_spec);
 
     const base::ListValue* exclude_domains = nullptr;
     net::ProxyBypassRules bypass_rules;
     if (onc_proxy_settings.GetListWithoutPathExpansion(
             ::onc::proxy::kExcludeDomains, &exclude_domains)) {
       bypass_rules.AssignFrom(
           ConvertOncExcludeDomainsToBypassRules(*exclude_domains));
     }
-    proxy_dict.reset(ProxyConfigDictionary::CreateFixedServers(
-        manual_spec, bypass_rules.ToString()));
+    proxy_dict = ProxyConfigDictionary::CreateFixedServers(
+        manual_spec, bypass_rules.ToString());
   } else {
     NOTREACHED();
   }
   return proxy_dict;
 }
 
 std::unique_ptr<base::DictionaryValue> ConvertProxyConfigToOncProxySettings(
     const base::DictionaryValue& proxy_config_value) {
   // Create a ProxyConfigDictionary from the DictionaryValue.
-  std::unique_ptr<ProxyConfigDictionary> proxy_config(
-      new ProxyConfigDictionary(&proxy_config_value));
+  auto proxy_config =
+      base::MakeUnique<ProxyConfigDictionary>(&proxy_config_value);

[stevenjb, 2017/03/30 20:39:54]

We should convert this to take a unique_ptr; taking the address of a const& is a
little wonky. We only call it twice and once we are dereferencing a unique_ptr
that is only used for calling this. The other time is in a test.

[vabr (Chromium), 2017/03/30 20:55:06]

Done.

 
   // Create the result DictionaryValue and populate it.
   std::unique_ptr<base::DictionaryValue> proxy_settings(
       new base::DictionaryValue);
   ProxyPrefs::ProxyMode mode;
   if (!proxy_config->GetMode(&mode))
     return nullptr;
   switch (mode) {
     case ProxyPrefs::MODE_DIRECT: {
       proxy_settings->SetStringWithoutPathExpansion(::onc::proxy::kType,
@@ skipping 340 matching lines @@
                          const PrefService* local_state_prefs,
                          const NetworkState& network) {
   ::onc::ONCSource ignored_onc_source;
   const base::DictionaryValue* policy = onc::GetPolicyForNetwork(
       profile_prefs, local_state_prefs, network, &ignored_onc_source);
   return policy != NULL;
 }
 
 }  // namespace onc
 }  // namespace chromeos