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

net/quic/chromium/quic_connection_logger.cc

 // Copyright (c) 2013 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/quic/chromium/quic_connection_logger.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/ip_address.h"
 #include "net/cert/x509_certificate.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_capture_mode.h"
@@ skipping 76 matching lines @@
   dict->SetInteger("stream_id", frame->stream_id);
   dict->SetBoolean("fin", frame->fin);
   dict->SetString("offset", base::Uint64ToString(frame->offset));
   dict->SetInteger("length", frame->data_length);
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogQuicAckFrameCallback(
     const QuicAckFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetString("largest_observed",
                   base::Uint64ToString(frame->largest_observed));
   dict->SetString("delta_time_largest_observed_us",
                   base::Int64ToString(frame->ack_delay_time.ToMicroseconds()));
 
-  base::ListValue* missing = new base::ListValue();
-  dict->Set("missing_packets", missing);
+  auto missing = base::MakeUnique<base::ListValue>();
   if (!frame->packets.Empty()) {
     // V34 and above express acked packets, but only print
     // missing packets, because it's typically a shorter list.
     for (QuicPacketNumber packet = frame->packets.Min();
          packet < frame->largest_observed; ++packet) {
       if (!frame->packets.Contains(packet)) {
         missing->AppendString(base::Uint64ToString(packet));
       }
     }
   }
+  dict->Set("missing_packets", std::move(missing));
 
-  base::ListValue* received = new base::ListValue();
-  dict->Set("received_packet_times", received);
+  auto received = base::MakeUnique<base::ListValue>();
   const PacketTimeVector& received_times = frame->received_packet_times;
   for (PacketTimeVector::const_iterator it = received_times.begin();
        it != received_times.end(); ++it) {
-    std::unique_ptr<base::DictionaryValue> info(new base::DictionaryValue());
+    auto info = base::MakeUnique<base::DictionaryValue>();
     info->SetInteger("packet_number", static_cast<int>(it->first));
     info->SetString("received",
                     base::Int64ToString(it->second.ToDebuggingValue()));
     received->Append(std::move(info));
   }
+  dict->Set("received_packet_times", std::move(received));
 
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogQuicRstStreamFrameCallback(
     const QuicRstStreamFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", frame->stream_id);
   dict->SetInteger("quic_rst_stream_error", frame->error_code);
@@ skipping 32 matching lines @@
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("quic_error", frame->error_code);
   dict->SetInteger("last_good_stream_id", frame->last_good_stream_id);
   dict->SetString("reason_phrase", frame->reason_phrase);
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogQuicStopWaitingFrameCallback(
     const QuicStopWaitingFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  base::DictionaryValue* sent_info = new base::DictionaryValue();
-  dict->Set("sent_info", sent_info);
+  auto dict = base::MakeUnique<base::DictionaryValue>();
+  auto sent_info = base::MakeUnique<base::DictionaryValue>();
   sent_info->SetString("least_unacked",
                        base::Uint64ToString(frame->least_unacked));
+  dict->Set("sent_info", std::move(sent_info));
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogQuicVersionNegotiationPacketCallback(
     const QuicVersionNegotiationPacket* packet,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  base::ListValue* versions = new base::ListValue();
-  dict->Set("versions", versions);
+  auto dict = base::MakeUnique<base::DictionaryValue>();
+  auto versions = base::MakeUnique<base::ListValue>();
   for (QuicVersionVector::const_iterator it = packet->versions.begin();
        it != packet->versions.end(); ++it) {
     versions->AppendString(QuicVersionToString(*it));
   }
+  dict->Set("versions", std::move(versions));
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogQuicPublicResetPacketCallback(
     const IPEndPoint* server_hello_address,
     const IPEndPoint* public_reset_address,
     NetLogCaptureMode /* capture_mode */) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("server_hello_address", server_hello_address->ToString());
   dict->SetString("public_reset_address", public_reset_address->ToString());
@@ skipping 20 matching lines @@
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogQuicCertificateVerifiedCallback(
     scoped_refptr<X509Certificate> cert,
     NetLogCaptureMode /* capture_mode */) {
   // Only the subjects are logged so that we can investigate connection pooling.
   // More fields could be logged in the future.
   std::vector<std::string> dns_names;
   cert->GetDNSNames(&dns_names);
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  base::ListValue* subjects = new base::ListValue();
-  for (std::vector<std::string>::const_iterator it = dns_names.begin();
-       it != dns_names.end(); it++) {
-    subjects->AppendString(*it);
+  auto dict = base::MakeUnique<base::DictionaryValue>();
+  auto subjects = base::MakeUnique<base::ListValue>();
+  for (auto& dns_name : dns_names) {
+    subjects->GetList().emplace_back(std::move(dns_name));
   }
-  dict->Set("subjects", subjects);
+  dict->Set("subjects", std::move(subjects));
   return std::move(dict);
 }
 
 void UpdatePublicResetAddressMismatchHistogram(
     const IPEndPoint& server_hello_address,
     const IPEndPoint& public_reset_address) {
   int sample = GetAddressMismatch(server_hello_address, public_reset_address);
   // We are seemingly talking to an older server that does not support the
   // feature, so we can't report the results in the histogram.
   if (sample < 0) {
@@ skipping 438 matching lines @@
 
   string prefix("Net.QuicSession.PacketLossRate_");
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
       prefix + connection_description_, 1, 1000, 75,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(static_cast<base::HistogramBase::Sample>(
       ReceivedPacketLossRate() * 1000));
 }
 
 }  // namespace net