Remove raw base::DictionaryValue::SetWithoutPathExpansion in //chromeos

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 <utility>
 
 #include "base/base64.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 590 matching lines @@
     DCHECK(entry_is_string);
 
     std::string pem_encoded;
     if (!GUIDRefToPEMEncoding(certs_by_guid, guid_ref, &pem_encoded))
       return false;
 
     pem_list->AppendString(pem_encoded);
   }
 
   onc_object->RemoveWithoutPathExpansion(key_guid_ref_list, nullptr);
-  onc_object->SetWithoutPathExpansion(key_pem_list, pem_list.release());
+  onc_object->SetWithoutPathExpansion(key_pem_list, std::move(pem_list));
   return true;
 }
 
 bool ResolveSingleCertRefToList(const CertPEMsByGUIDMap& certs_by_guid,
                                 const std::string& key_guid_ref,
                                 const std::string& key_pem_list,
                                 base::DictionaryValue* onc_object) {
   std::string guid_ref;
   if (!onc_object->GetStringWithoutPathExpansion(key_guid_ref, &guid_ref))
     return true;
 
   std::string pem_encoded;
   if (!GUIDRefToPEMEncoding(certs_by_guid, guid_ref, &pem_encoded))
     return false;
 
   std::unique_ptr<base::ListValue> pem_list(new base::ListValue);
   pem_list->AppendString(pem_encoded);
   onc_object->RemoveWithoutPathExpansion(key_guid_ref, nullptr);
-  onc_object->SetWithoutPathExpansion(key_pem_list, pem_list.release());
+  onc_object->SetWithoutPathExpansion(key_pem_list, std::move(pem_list));
   return true;
 }
 
 // Resolves the reference list at |key_guid_refs| if present and otherwise the
 // single reference at |key_guid_ref|. Returns whether the respective resolving
 // was successful.
 bool ResolveCertRefsOrRefToList(const CertPEMsByGUIDMap& certs_by_guid,
                                 const std::string& key_guid_refs,
                                 const std::string& key_guid_ref,
                                 const std::string& key_pem_list,
@@ skipping 260 matching lines @@
   // HTTP.
   net::ProxyServer::Scheme default_scheme =
       (onc_scheme == ::onc::proxy::kSocks) ? net::ProxyServer::SCHEME_SOCKS4
                                            : net::ProxyServer::SCHEME_HTTP;
   // Only prefix the host with a non-default scheme.
   if (server.scheme() != default_scheme)
     host = SchemeToString(server.scheme()) + "://" + host;
   url_dict->SetStringWithoutPathExpansion(::onc::proxy::kHost, host);
   url_dict->SetIntegerWithoutPathExpansion(::onc::proxy::kPort,
                                            server.host_port_pair().port());
-  dict->SetWithoutPathExpansion(onc_scheme, url_dict.release());
+  dict->SetWithoutPathExpansion(onc_scheme, std::move(url_dict));
 }
 
 }  // 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;
 
@@ skipping 77 matching lines @@
         SetProxyForScheme(proxy_rules, url::kFtpScheme, ::onc::proxy::kFtp,
                           manual.get());
         SetProxyForScheme(proxy_rules, url::kHttpScheme, ::onc::proxy::kHttp,
                           manual.get());
         SetProxyForScheme(proxy_rules, url::kHttpsScheme, ::onc::proxy::kHttps,
                           manual.get());
         SetProxyForScheme(proxy_rules, kSocksScheme, ::onc::proxy::kSocks,
                           manual.get());
       }
       proxy_settings->SetWithoutPathExpansion(::onc::proxy::kManual,
-                                              manual.release());
+                                              std::move(manual));
 
       // Convert the 'bypass_list' string into dictionary entries.
       std::string bypass_rules_string;
       if (proxy_config->GetBypassList(&bypass_rules_string)) {
         net::ProxyBypassRules bypass_rules;
         bypass_rules.ParseFromString(bypass_rules_string);
         std::unique_ptr<base::ListValue> exclude_domains(new base::ListValue);
         for (const auto& rule : bypass_rules.rules())
           exclude_domains->AppendString(rule->ToString());
         if (!exclude_domains->empty()) {
           proxy_settings->SetWithoutPathExpansion(::onc::proxy::kExcludeDomains,
-                                                  exclude_domains.release());
+                                                  std::move(exclude_domains));
         }
       }
       break;
     }
     default: {
       LOG(ERROR) << "Unexpected proxy mode in Shill config: " << mode;
       return nullptr;
     }
   }
   return proxy_settings;
@@ skipping 283 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