Remove raw base::DictionaryValue::SetWithoutPathExpansion

net/http/http_server_properties_manager.cc

 // Copyright 2014 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 "net/http/http_server_properties_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 995 matching lines @@
       ServerPref server_pref;
       server_pref.server_network_stats = &map_it->second;
       server_pref_map.Put(server, server_pref);
     } else {
       it->second.server_network_stats = &map_it->second;
     }
   }
 
   // Persist properties to the prefs in the MRU order.
   base::DictionaryValue http_server_properties_dict;
-  base::ListValue* servers_list = new base::ListValue;
+  auto servers_list = base::MakeUnique<base::ListValue>();
   for (ServerPrefMap::const_reverse_iterator map_it = server_pref_map.rbegin();
        map_it != server_pref_map.rend(); ++map_it) {
     const url::SchemeHostPort server = map_it->first;
     const ServerPref& server_pref = map_it->second;
 
     auto servers_dict = base::MakeUnique<base::DictionaryValue>();
     auto server_pref_dict = base::MakeUnique<base::DictionaryValue>();
 
     // Save supports_spdy.
     if (server_pref.supports_spdy)
       server_pref_dict->SetBoolean(kSupportsSpdyKey, server_pref.supports_spdy);
     SaveAlternativeServiceToServerPrefs(
         server_pref.alternative_service_info_vector, server_pref_dict.get());
     SaveNetworkStatsToServerPrefs(server_pref.server_network_stats,
                                   server_pref_dict.get());
 
     servers_dict->SetWithoutPathExpansion(server.Serialize(),
                                           std::move(server_pref_dict));
     bool value = servers_list->AppendIfNotPresent(std::move(servers_dict));
     DCHECK(value);  // Should never happen.
   }
 
   http_server_properties_dict.SetWithoutPathExpansion(kServersKey,
-                                                      servers_list);
+                                                      std::move(servers_list));
   SetVersion(&http_server_properties_dict, kVersionNumber);
 
   SaveSupportsQuicToPrefs(last_quic_address, &http_server_properties_dict);
 
   SaveQuicServerInfoMapToServerPrefs(quic_server_info_map,
                                      &http_server_properties_dict);
 
   setting_prefs_ = true;
   pref_delegate_->SetServerProperties(http_server_properties_dict);
   setting_prefs_ = false;
@@ skipping 30 matching lines @@
         kProtocolKey, NextProtoToString(alternative_service.protocol));
     // JSON cannot store int64_t, so expiration is converted to a string.
     alternative_service_dict->SetString(
         kExpirationKey,
         base::Int64ToString(
             alternative_service_info.expiration.ToInternalValue()));
     alternative_service_list->Append(std::move(alternative_service_dict));
   }
   if (alternative_service_list->GetSize() == 0)
     return;
-  server_pref_dict->SetWithoutPathExpansion(kAlternativeServiceKey,
-                                            alternative_service_list.release());
+  server_pref_dict->SetWithoutPathExpansion(
+      kAlternativeServiceKey, std::move(alternative_service_list));
 }
 
 void HttpServerPropertiesManager::SaveSupportsQuicToPrefs(
     const IPAddress* last_quic_address,
     base::DictionaryValue* http_server_properties_dict) {
   if (!last_quic_address || !last_quic_address->IsValid())
     return;
 
-  base::DictionaryValue* supports_quic_dict = new base::DictionaryValue;
+  auto supports_quic_dict = base::MakeUnique<base::DictionaryValue>();
   supports_quic_dict->SetBoolean(kUsedQuicKey, true);
   supports_quic_dict->SetString(kAddressKey, last_quic_address->ToString());
-  http_server_properties_dict->SetWithoutPathExpansion(kSupportsQuicKey,
-                                                       supports_quic_dict);
+  http_server_properties_dict->SetWithoutPathExpansion(
+      kSupportsQuicKey, std::move(supports_quic_dict));
 }
 
 void HttpServerPropertiesManager::SaveNetworkStatsToServerPrefs(
     const ServerNetworkStats* server_network_stats,
     base::DictionaryValue* server_pref_dict) {
   if (!server_network_stats)
     return;
 
-  base::DictionaryValue* server_network_stats_dict = new base::DictionaryValue;
+  auto server_network_stats_dict = base::MakeUnique<base::DictionaryValue>();
   // Becasue JSON doesn't support int64_t, persist int64_t as a string.
   server_network_stats_dict->SetInteger(
       kSrttKey, static_cast<int>(server_network_stats->srtt.ToInternalValue()));
   // TODO(rtenneti): When QUIC starts using bandwidth_estimate, then persist
   // bandwidth_estimate.
-  server_pref_dict->SetWithoutPathExpansion(kNetworkStatsKey,
-                                            server_network_stats_dict);
+  server_pref_dict->SetWithoutPathExpansion(
+      kNetworkStatsKey, std::move(server_network_stats_dict));
 }
 
 void HttpServerPropertiesManager::SaveQuicServerInfoMapToServerPrefs(
     QuicServerInfoMap* quic_server_info_map,
     base::DictionaryValue* http_server_properties_dict) {
   if (!quic_server_info_map)
     return;
 
-  base::DictionaryValue* quic_servers_dict = new base::DictionaryValue;
+  auto quic_servers_dict = base::MakeUnique<base::DictionaryValue>();
   for (const std::pair<QuicServerId, std::string>& entry :
        *quic_server_info_map) {
     const QuicServerId& server_id = entry.first;
-    base::DictionaryValue* quic_server_pref_dict = new base::DictionaryValue;
+    auto quic_server_pref_dict = base::MakeUnique<base::DictionaryValue>();
     quic_server_pref_dict->SetStringWithoutPathExpansion(kServerInfoKey,
                                                          entry.second);
-    quic_servers_dict->SetWithoutPathExpansion(server_id.ToString(),
-                                               quic_server_pref_dict);
+    quic_servers_dict->SetWithoutPathExpansion(
+        server_id.ToString(), std::move(quic_server_pref_dict));
   }
-  http_server_properties_dict->SetWithoutPathExpansion(kQuicServers,
-                                                       quic_servers_dict);
+  http_server_properties_dict->SetWithoutPathExpansion(
+      kQuicServers, std::move(quic_servers_dict));
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 void HttpServerPropertiesManager::SetInitialized() {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   is_initialized_ = true;
 }
 
 }  // namespace net