Remove raw base::DictionaryValue::Set in //net

net/log/net_log_util.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/log/net_log_util.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/address_family.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/sdch_manager.h"
@@ skipping 233 matching lines @@
     constants_dict->Set("logEventPhase", std::move(dict));
   }
 
   // Information about the relationship between source type enums and
   // their symbolic names.
   constants_dict->Set("logSourceType", NetLog::GetSourceTypesAsValue());
 
   // TODO(eroman): This is here for compatibility in loading new log files with
   // older builds of Chrome. Safe to remove this once M45 is on the stable
   // channel.
-  constants_dict->Set("logLevelType", new base::DictionaryValue());
+  constants_dict->Set("logLevelType",
+                      base::MakeUnique<base::DictionaryValue>());
 
   // Information about the relationship between address family enums and
   // their symbolic names.
   {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
     dict->SetInteger("ADDRESS_FAMILY_UNSPECIFIED", ADDRESS_FAMILY_UNSPECIFIED);
     dict->SetInteger("ADDRESS_FAMILY_IPV4", ADDRESS_FAMILY_IPV4);
     dict->SetInteger("ADDRESS_FAMILY_IPV6", ADDRESS_FAMILY_IPV6);
 
@@ skipping 18 matching lines @@
     int64_t tick_to_unix_time_ms =
         (time_since_epoch - reference_time_ticks).InMilliseconds();
 
     // Pass it as a string, since it may be too large to fit in an integer.
     constants_dict->SetString("timeTickOffset",
                               base::Int64ToString(tick_to_unix_time_ms));
   }
 
   // "clientInfo" key is required for some WriteToFileNetLogObserver log
   // readers. Provide a default empty value for compatibility.
-  constants_dict->Set("clientInfo", new base::DictionaryValue());
+  constants_dict->Set("clientInfo", base::MakeUnique<base::DictionaryValue>());
 
   // Add a list of active field experiments.
   {
     base::FieldTrial::ActiveGroups active_groups;
     base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
-    base::ListValue* field_trial_groups = new base::ListValue();
+    auto field_trial_groups = base::MakeUnique<base::ListValue>();
     for (base::FieldTrial::ActiveGroups::const_iterator it =
              active_groups.begin();
          it != active_groups.end(); ++it) {
       field_trial_groups->AppendString(it->trial_name + ":" + it->group_name);
     }
-    constants_dict->Set("activeFieldTrialGroups", field_trial_groups);
+    constants_dict->Set("activeFieldTrialGroups",
+                        std::move(field_trial_groups));
   }
 
   return constants_dict;
 }
 
 NET_EXPORT std::unique_ptr<base::DictionaryValue> GetNetInfo(
     URLRequestContext* context,
     int info_sources) {
   // May only be called on the context's thread.
   DCHECK(context->CalledOnValidThread());
@@ skipping 13 matching lines @@
       dict->Set("effective", proxy_service->config().ToValue());
 
     net_info_dict->Set(NetInfoSourceToString(NET_INFO_PROXY_SETTINGS),
                        std::move(dict));
   }
 
   if (info_sources & NET_INFO_BAD_PROXIES) {
     const ProxyRetryInfoMap& bad_proxies_map =
         context->proxy_service()->proxy_retry_info();
 
-    base::ListValue* list = new base::ListValue();
+    auto list = base::MakeUnique<base::ListValue>();
 
     for (ProxyRetryInfoMap::const_iterator it = bad_proxies_map.begin();
          it != bad_proxies_map.end(); ++it) {
       const std::string& proxy_uri = it->first;
       const ProxyRetryInfo& retry_info = it->second;
 
-      std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+      auto dict = base::MakeUnique<base::DictionaryValue>();
       dict->SetString("proxy_uri", proxy_uri);
       dict->SetString("bad_until",
                       NetLog::TickCountToString(retry_info.bad_until));
 
       list->Append(std::move(dict));
     }
 
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_BAD_PROXIES), list);
+    net_info_dict->Set(NetInfoSourceToString(NET_INFO_BAD_PROXIES),
+                       std::move(list));
   }
 
   if (info_sources & NET_INFO_HOST_RESOLVER) {
     HostResolver* host_resolver = context->host_resolver();
     DCHECK(host_resolver);
     HostCache* cache = host_resolver->GetHostCache();
     if (cache) {
-      std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+      auto dict = base::MakeUnique<base::DictionaryValue>();
       std::unique_ptr<base::Value> dns_config =
           host_resolver->GetDnsConfigAsValue();
       if (dns_config)
         dict->Set("dns_config", std::move(dns_config));
 
-      base::DictionaryValue* cache_info_dict = new base::DictionaryValue();
+      auto cache_info_dict = base::MakeUnique<base::DictionaryValue>();
 
       cache_info_dict->SetInteger("capacity",
                                   static_cast<int>(cache->max_entries()));
       cache_info_dict->SetInteger("network_changes", cache->network_changes());
 
       cache_info_dict->Set("entries",
                            cache->GetAsListValue(/*include_staleness=*/true));
-      dict->Set("cache", cache_info_dict);
+      dict->Set("cache", std::move(cache_info_dict));
       net_info_dict->Set(NetInfoSourceToString(NET_INFO_HOST_RESOLVER),
                          std::move(dict));
     }
   }
 
   HttpNetworkSession* http_network_session =
       context->http_transaction_factory()->GetSession();
 
   if (info_sources & NET_INFO_SOCKET_POOL) {
     net_info_dict->Set(NetInfoSourceToString(NET_INFO_SOCKET_POOL),
                        http_network_session->SocketPoolInfoToValue());
   }
 
   if (info_sources & NET_INFO_SPDY_SESSIONS) {
     net_info_dict->Set(NetInfoSourceToString(NET_INFO_SPDY_SESSIONS),
                        http_network_session->SpdySessionPoolInfoToValue());
   }
 
   if (info_sources & NET_INFO_SPDY_STATUS) {
-    base::DictionaryValue* status_dict = new base::DictionaryValue();
+    auto status_dict = base::MakeUnique<base::DictionaryValue>();
 
     status_dict->SetBoolean("enable_http2",
                             http_network_session->params().enable_http2);
 
     NextProtoVector alpn_protos;
     http_network_session->GetAlpnProtos(&alpn_protos);
     if (!alpn_protos.empty()) {
       std::string next_protos_string;
       for (NextProto proto : alpn_protos) {
         if (!next_protos_string.empty())
           next_protos_string.append(",");
         next_protos_string.append(NextProtoToString(proto));
       }
       status_dict->SetString("alpn_protos", next_protos_string);
     }
 
     net_info_dict->Set(NetInfoSourceToString(NET_INFO_SPDY_STATUS),
-                       status_dict);
+                       std::move(status_dict));
   }
 
   if (info_sources & NET_INFO_ALT_SVC_MAPPINGS) {
     const HttpServerProperties& http_server_properties =
         *context->http_server_properties();
     net_info_dict->Set(
         NetInfoSourceToString(NET_INFO_ALT_SVC_MAPPINGS),
         http_server_properties.GetAlternativeServiceInfoAsValue());
   }
 
   if (info_sources & NET_INFO_QUIC) {
     net_info_dict->Set(NetInfoSourceToString(NET_INFO_QUIC),
                        http_network_session->QuicInfoToValue());
   }
 
   if (info_sources & NET_INFO_HTTP_CACHE) {
-    base::DictionaryValue* info_dict = new base::DictionaryValue();
-    base::DictionaryValue* stats_dict = new base::DictionaryValue();
+    auto info_dict = base::MakeUnique<base::DictionaryValue>();
+    auto stats_dict = base::MakeUnique<base::DictionaryValue>();
 
     disk_cache::Backend* disk_cache = GetDiskCacheBackend(context);
 
     if (disk_cache) {
       // Extract the statistics key/value pairs from the backend.
       base::StringPairs stats;
       disk_cache->GetStats(&stats);
       for (size_t i = 0; i < stats.size(); ++i) {
         stats_dict->SetStringWithoutPathExpansion(stats[i].first,
                                                   stats[i].second);
       }
     }
-    info_dict->Set("stats", stats_dict);
+    info_dict->Set("stats", std::move(stats_dict));
 
-    net_info_dict->Set(NetInfoSourceToString(NET_INFO_HTTP_CACHE), info_dict);
+    net_info_dict->Set(NetInfoSourceToString(NET_INFO_HTTP_CACHE),
+                       std::move(info_dict));
   }
 
   if (info_sources & NET_INFO_SDCH) {
     std::unique_ptr<base::Value> info_dict;
     SdchManager* sdch_manager = context->sdch_manager();
     if (sdch_manager) {
       info_dict = sdch_manager->SdchInfoToValue();
     } else {
       info_dict.reset(new base::DictionaryValue());
     }
@@ skipping 31 matching lines @@
     // fine, since GetRequestStateAsValue() ignores the capture mode.
     NetLogEntryData entry_data(
         NetLogEventType::REQUEST_ALIVE, request->net_log().source(),
         NetLogEventPhase::BEGIN, request->creation_time(), &callback);
     NetLogEntry entry(&entry_data, NetLogCaptureMode::Default());
     observer->OnAddEntry(entry);
   }
 }
 
 }  // namespace net