Updated NetLog::ParametersCallback & all related calbacks returning value as scoped_ptr<base::Value…

net/quic/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/quic_connection_logger.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 
 namespace net {
 
 namespace {
 
 // We have ranges-of-buckets in the cumulative histogram (covering 21 packet
 // sequences) of length 2, 3, 4, ... 22.
 // Hence the largest sample is bounded by the sum of those numbers.
 const int kBoundingSampleInCumulativeHistogram = ((2 + 22) * 21) / 2;
 
-base::Value* NetLogQuicPacketCallback(const IPEndPoint* self_address,
-                                      const IPEndPoint* peer_address,
-                                      size_t packet_size,
-                                      NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+scoped_ptr<base::Value> NetLogQuicPacketCallback(
+    const IPEndPoint* self_address,
+    const IPEndPoint* peer_address,
+    size_t packet_size,
+    NetLogCaptureMode /* capture_mode */) {
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("self_address", self_address->ToString());
   dict->SetString("peer_address", peer_address->ToString());
   dict->SetInteger("size", packet_size);
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicPacketSentCallback(
+scoped_ptr<base::Value> NetLogQuicPacketSentCallback(
     const SerializedPacket& serialized_packet,
     EncryptionLevel level,
     TransmissionType transmission_type,
     size_t packet_size,
     QuicTime sent_time,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("encryption_level", level);
   dict->SetInteger("transmission_type", transmission_type);
   dict->SetString("packet_sequence_number",
                   base::Uint64ToString(serialized_packet.sequence_number));
   dict->SetInteger("size", packet_size);
   dict->SetInteger("sent_time_us",
                    static_cast<int>(sent_time.ToDebuggingValue()));
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicPacketRetransmittedCallback(
+scoped_ptr<base::Value> NetLogQuicPacketRetransmittedCallback(
     QuicPacketSequenceNumber old_sequence_number,
     QuicPacketSequenceNumber new_sequence_number,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("old_packet_sequence_number",
                   base::Uint64ToString(old_sequence_number));
   dict->SetString("new_packet_sequence_number",
                   base::Uint64ToString(new_sequence_number));
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicPacketHeaderCallback(
+scoped_ptr<base::Value> NetLogQuicPacketHeaderCallback(
     const QuicPacketHeader* header,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("connection_id",
                   base::Uint64ToString(header->public_header.connection_id));
   dict->SetInteger("reset_flag", header->public_header.reset_flag);
   dict->SetInteger("version_flag", header->public_header.version_flag);
   dict->SetString("packet_sequence_number",
                   base::Uint64ToString(header->packet_sequence_number));
   dict->SetInteger("entropy_flag", header->entropy_flag);
   dict->SetInteger("fec_flag", header->fec_flag);
   dict->SetInteger("fec_group", static_cast<int>(header->fec_group));
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicStreamFrameCallback(
+scoped_ptr<base::Value> NetLogQuicStreamFrameCallback(
     const QuicStreamFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", frame->stream_id);
   dict->SetBoolean("fin", frame->fin);
   dict->SetString("offset", base::Uint64ToString(frame->offset));
   dict->SetInteger("length", frame->data.TotalBufferSize());
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame,
-                                        NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+scoped_ptr<base::Value> NetLogQuicAckFrameCallback(
+    const QuicAckFrame* frame,
+    NetLogCaptureMode /* capture_mode */) {
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("largest_observed",
                   base::Uint64ToString(frame->largest_observed));
   dict->SetInteger(
       "delta_time_largest_observed_us",
       static_cast<int>(frame->delta_time_largest_observed.ToMicroseconds()));
   dict->SetInteger("entropy_hash",
                    frame->entropy_hash);
   dict->SetBoolean("truncated", frame->is_truncated);
 
-  base::ListValue* missing = new base::ListValue();
-  dict->Set("missing_packets", missing);
+  scoped_ptr<base::ListValue> missing(new base::ListValue());
+  dict->Set("missing_packets", missing.Pass());
   const SequenceNumberSet& missing_packets = frame->missing_packets;
   for (SequenceNumberSet::const_iterator it = missing_packets.begin();
        it != missing_packets.end(); ++it) {
     missing->AppendString(base::Uint64ToString(*it));
   }
 
-  base::ListValue* revived = new base::ListValue();
-  dict->Set("revived_packets", revived);
+  scoped_ptr<base::ListValue> revived(new base::ListValue());
+  dict->Set("revived_packets", revived.Pass());
   const SequenceNumberSet& revived_packets = frame->revived_packets;
   for (SequenceNumberSet::const_iterator it = revived_packets.begin();
        it != revived_packets.end(); ++it) {
     revived->AppendString(base::Uint64ToString(*it));
   }
 
-  base::ListValue* received = new base::ListValue();
-  dict->Set("received_packet_times", received);
+  scoped_ptr<base::ListValue> received(new base::ListValue());
+  dict->Set("received_packet_times", received.Pass());
   const PacketTimeList& received_times = frame->received_packet_times;
   for (PacketTimeList::const_iterator it = received_times.begin();
        it != received_times.end(); ++it) {
-    base::DictionaryValue* info = new base::DictionaryValue();
+    scoped_ptr<base::DictionaryValue> info(new base::DictionaryValue());
     info->SetInteger("sequence_number", static_cast<int>(it->first));
     info->SetInteger("received",
                      static_cast<int>(it->second.ToDebuggingValue()));
-    received->Append(info);
+    received->Append(info.get());
   }
 
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicRstStreamFrameCallback(
+scoped_ptr<base::Value> NetLogQuicRstStreamFrameCallback(
     const QuicRstStreamFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", frame->stream_id);
   dict->SetInteger("quic_rst_stream_error", frame->error_code);
   dict->SetString("details", frame->error_details);
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicConnectionCloseFrameCallback(
+scoped_ptr<base::Value> NetLogQuicConnectionCloseFrameCallback(
     const QuicConnectionCloseFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("quic_error", frame->error_code);
   dict->SetString("details", frame->error_details);
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicWindowUpdateFrameCallback(
+scoped_ptr<base::Value> NetLogQuicWindowUpdateFrameCallback(
     const QuicWindowUpdateFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", frame->stream_id);
   dict->SetString("byte_offset", base::Uint64ToString(frame->byte_offset));
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicBlockedFrameCallback(
+scoped_ptr<base::Value> NetLogQuicBlockedFrameCallback(
     const QuicBlockedFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", frame->stream_id);
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicGoAwayFrameCallback(
+scoped_ptr<base::Value> NetLogQuicGoAwayFrameCallback(
     const QuicGoAwayFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_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 dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicStopWaitingFrameCallback(
+scoped_ptr<base::Value> NetLogQuicStopWaitingFrameCallback(
     const QuicStopWaitingFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  base::DictionaryValue* sent_info = new base::DictionaryValue();
-  dict->Set("sent_info", sent_info);
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  scoped_ptr<base::DictionaryValue> sent_info(new base::DictionaryValue());
+  dict->Set("sent_info", sent_info.get());
   sent_info->SetString("least_unacked",
                        base::Uint64ToString(frame->least_unacked));
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicVersionNegotiationPacketCallback(
+scoped_ptr<base::Value> NetLogQuicVersionNegotiationPacketCallback(
     const QuicVersionNegotiationPacket* packet,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  base::ListValue* versions = new base::ListValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  base::ListValue* versions(new base::ListValue());
   dict->Set("versions", versions);
   for (QuicVersionVector::const_iterator it = packet->versions.begin();
        it != packet->versions.end(); ++it) {
     versions->AppendString(QuicVersionToString(*it));
   }
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicCryptoHandshakeMessageCallback(
+scoped_ptr<base::Value> NetLogQuicCryptoHandshakeMessageCallback(
     const CryptoHandshakeMessage* message,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("quic_crypto_handshake_message", message->DebugString());
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicOnConnectionClosedCallback(
+scoped_ptr<base::Value> NetLogQuicOnConnectionClosedCallback(
     QuicErrorCode error,
     bool from_peer,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("quic_error", error);
   dict->SetBoolean("from_peer", from_peer);
-  return dict;
+  return dict.Pass();
 }
 
-base::Value* NetLogQuicCertificateVerifiedCallback(
+scoped_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);
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  base::ListValue* subjects = new base::ListValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  scoped_ptr<base::ListValue> subjects(new base::ListValue());
   for (std::vector<std::string>::const_iterator it = dns_names.begin();
        it != dns_names.end(); it++) {
     subjects->Append(new base::StringValue(*it));
   }
-  dict->Set("subjects", subjects);
-  return dict;
+  dict->Set("subjects", subjects.Pass());
+  return dict.Pass();
 }
 
 void UpdatePacketGapSentHistogram(size_t num_consecutive_missing_packets) {
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.PacketGapSent",
                        num_consecutive_missing_packets);
 }
 
 void UpdatePublicResetAddressMismatchHistogram(
     const IPEndPoint& server_hello_address,
     const IPEndPoint& public_reset_address) {
@@ skipping 82 matching lines @@
   RecordLossHistograms();
 }
 
 void QuicConnectionLogger::OnFrameAddedToPacket(const QuicFrame& frame) {
   switch (frame.type) {
     case PADDING_FRAME:
       break;
     case STREAM_FRAME:
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_SENT,
-          base::Bind(&NetLogQuicStreamFrameCallback, frame.stream_frame));
+          base::Bind(NetLogQuicStreamFrameCallback, frame.stream_frame));
       break;
     case ACK_FRAME: {
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_ACK_FRAME_SENT,
-          base::Bind(&NetLogQuicAckFrameCallback, frame.ack_frame));
+          base::Bind(NetLogQuicAckFrameCallback, frame.ack_frame));
       const SequenceNumberSet& missing_packets =
           frame.ack_frame->missing_packets;
       const uint8 max_ranges = std::numeric_limits<uint8>::max();
       // Compute an upper bound on the number of NACK ranges. If the bound
       // is below the max, then it clearly isn't truncated.
       if (missing_packets.size() < max_ranges ||
           (*missing_packets.rbegin() - *missing_packets.begin() -
            missing_packets.size() + 1) < max_ranges) {
         break;
       }
       size_t num_ranges = 0;
       QuicPacketSequenceNumber last_missing = 0;
       for (SequenceNumberSet::const_iterator it = missing_packets.begin();
            it != missing_packets.end(); ++it) {
         if (*it != last_missing + 1 && ++num_ranges >= max_ranges) {
           ++num_truncated_acks_sent_;
           break;
         }
         last_missing = *it;
       }
       break;
     }
     case RST_STREAM_FRAME:
       UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeClient",
                                   frame.rst_stream_frame->error_code);
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_SENT,
-          base::Bind(&NetLogQuicRstStreamFrameCallback,
-                     frame.rst_stream_frame));
+          base::Bind(NetLogQuicRstStreamFrameCallback, frame.rst_stream_frame));
       break;
     case CONNECTION_CLOSE_FRAME:
-      net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_CONNECTION_CLOSE_FRAME_SENT,
-          base::Bind(&NetLogQuicConnectionCloseFrameCallback,
-                     frame.connection_close_frame));
+      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_CONNECTION_CLOSE_FRAME_SENT,
+                        base::Bind(NetLogQuicConnectionCloseFrameCallback,
+                                   frame.connection_close_frame));
       break;
     case GOAWAY_FRAME:
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_GOAWAY_FRAME_SENT,
-          base::Bind(&NetLogQuicGoAwayFrameCallback,
-                     frame.goaway_frame));
+          base::Bind(NetLogQuicGoAwayFrameCallback, frame.goaway_frame));
       break;
     case WINDOW_UPDATE_FRAME:
-      net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_SENT,
-          base::Bind(&NetLogQuicWindowUpdateFrameCallback,
-                     frame.window_update_frame));
+      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_SENT,
+                        base::Bind(NetLogQuicWindowUpdateFrameCallback,
+                                   frame.window_update_frame));
       break;
     case BLOCKED_FRAME:
       ++num_blocked_frames_sent_;
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_BLOCKED_FRAME_SENT,
-          base::Bind(&NetLogQuicBlockedFrameCallback,
-                     frame.blocked_frame));
+          base::Bind(NetLogQuicBlockedFrameCallback, frame.blocked_frame));
       break;
     case STOP_WAITING_FRAME:
-      net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_SENT,
-          base::Bind(&NetLogQuicStopWaitingFrameCallback,
-                     frame.stop_waiting_frame));
+      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_SENT,
+                        base::Bind(NetLogQuicStopWaitingFrameCallback,
+                                   frame.stop_waiting_frame));
       break;
     case PING_FRAME:
       UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.ConnectionFlowControlBlocked",
                             session_->IsConnectionFlowControlBlocked());
       UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.StreamFlowControlBlocked",
                             session_->IsStreamFlowControlBlocked());
       // PingFrame has no contents to log, so just record that it was sent.
       net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PING_FRAME_SENT);
       break;
     default:
       DCHECK(false) << "Illegal frame type: " << frame.type;
   }
 }
 
 void QuicConnectionLogger::OnPacketSent(
     const SerializedPacket& serialized_packet,
     QuicPacketSequenceNumber original_sequence_number,
     EncryptionLevel level,
     TransmissionType transmission_type,
     const QuicEncryptedPacket& packet,
     QuicTime sent_time) {
   if (original_sequence_number == 0) {
     net_log_.AddEvent(
         NetLog::TYPE_QUIC_SESSION_PACKET_SENT,
-        base::Bind(&NetLogQuicPacketSentCallback, serialized_packet,
-                   level, transmission_type, packet.length(), sent_time));
+        base::Bind(NetLogQuicPacketSentCallback, serialized_packet, level,
+                   transmission_type, packet.length(), sent_time));
   }  else {
-    net_log_.AddEvent(
-        NetLog::TYPE_QUIC_SESSION_PACKET_RETRANSMITTED,
-        base::Bind(&NetLogQuicPacketRetransmittedCallback,
-                   original_sequence_number,
-                   serialized_packet.sequence_number));
+    net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PACKET_RETRANSMITTED,
+                      base::Bind(NetLogQuicPacketRetransmittedCallback,
+                                 original_sequence_number,
+                                 serialized_packet.sequence_number));
   }
 }
 
 void QuicConnectionLogger::OnPacketReceived(const IPEndPoint& self_address,
                                             const IPEndPoint& peer_address,
                                             const QuicEncryptedPacket& packet) {
   if (local_address_from_self_.GetFamily() == ADDRESS_FAMILY_UNSPECIFIED) {
     local_address_from_self_ = self_address;
     UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.ConnectionTypeFromSelf",
                               GetRealAddressFamily(self_address.address()),
                               ADDRESS_FAMILY_LAST);
   }
 
   previous_received_packet_size_ = last_received_packet_size_;
   last_received_packet_size_ = packet.length();
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
-      base::Bind(&NetLogQuicPacketCallback, &self_address, &peer_address,
-                 packet.length()));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
+                    base::Bind(NetLogQuicPacketCallback, &self_address,
+                               &peer_address, packet.length()));
 }
 
 void QuicConnectionLogger::OnIncorrectConnectionId(
     QuicConnectionId connection_id) {
   ++num_incorrect_connection_ids_;
 }
 
 void QuicConnectionLogger::OnUndecryptablePacket() {
   ++num_undecryptable_packets_;
 }
 
 void QuicConnectionLogger::OnDuplicatePacket(
     QuicPacketSequenceNumber sequence_number) {
   ++num_duplicate_packets_;
 }
 
 void QuicConnectionLogger::OnProtocolVersionMismatch(
     QuicVersion received_version) {
   // TODO(rtenneti): Add logging.
 }
 
 void QuicConnectionLogger::OnPacketHeader(const QuicPacketHeader& header) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_PACKET_HEADER_RECEIVED,
-      base::Bind(&NetLogQuicPacketHeaderCallback, &header));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PACKET_HEADER_RECEIVED,
+                    base::Bind(NetLogQuicPacketHeaderCallback, &header));
   ++num_packets_received_;
   if (largest_received_packet_sequence_number_ <
       header.packet_sequence_number) {
     QuicPacketSequenceNumber delta = header.packet_sequence_number -
         largest_received_packet_sequence_number_;
     if (delta > 1) {
       // There is a gap between the largest packet previously received and
       // the current packet.  This indicates either loss, or out-of-order
       // delivery.
       UMA_HISTOGRAM_COUNTS("Net.QuicSession.PacketGapReceived",
@@ skipping 12 matching lines @@
     UMA_HISTOGRAM_COUNTS(
         "Net.QuicSession.OutOfOrderGapReceived",
         static_cast<base::HistogramBase::Sample>(
             last_received_packet_sequence_number_ -
             header.packet_sequence_number));
   }
   last_received_packet_sequence_number_ = header.packet_sequence_number;
 }
 
 void QuicConnectionLogger::OnStreamFrame(const QuicStreamFrame& frame) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicStreamFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED,
+                    base::Bind(NetLogQuicStreamFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnAckFrame(const QuicAckFrame& frame) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_ACK_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicAckFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_ACK_FRAME_RECEIVED,
+                    base::Bind(NetLogQuicAckFrameCallback, &frame));
 
   const size_t kApproximateLargestSoloAckBytes = 100;
   if (last_received_packet_sequence_number_ < received_acks_.size() &&
       last_received_packet_size_ < kApproximateLargestSoloAckBytes) {
     received_acks_[static_cast<size_t>(last_received_packet_sequence_number_)] =
         true;
   }
 
   if (frame.is_truncated)
     ++num_truncated_acks_received_;
@@ skipping 29 matching lines @@
   }
   if (num_consecutive_missing_packets != 0) {
     UpdatePacketGapSentHistogram(num_consecutive_missing_packets);
   }
   largest_received_missing_packet_sequence_number_ =
         *missing_packets.rbegin();
 }
 
 void QuicConnectionLogger::OnStopWaitingFrame(
     const QuicStopWaitingFrame& frame) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicStopWaitingFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_RECEIVED,
+                    base::Bind(NetLogQuicStopWaitingFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeServer",
                               frame.error_code);
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicRstStreamFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_RECEIVED,
+                    base::Bind(NetLogQuicRstStreamFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnConnectionCloseFrame(
     const QuicConnectionCloseFrame& frame) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_CONNECTION_CLOSE_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicConnectionCloseFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_CONNECTION_CLOSE_FRAME_RECEIVED,
+                    base::Bind(NetLogQuicConnectionCloseFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnWindowUpdateFrame(
     const QuicWindowUpdateFrame& frame) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicWindowUpdateFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_RECEIVED,
+                    base::Bind(NetLogQuicWindowUpdateFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnBlockedFrame(const QuicBlockedFrame& frame) {
   ++num_blocked_frames_received_;
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_BLOCKED_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicBlockedFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_BLOCKED_FRAME_RECEIVED,
+                    base::Bind(NetLogQuicBlockedFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_GOAWAY_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicGoAwayFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_GOAWAY_FRAME_RECEIVED,
+                    base::Bind(NetLogQuicGoAwayFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnPingFrame(const QuicPingFrame& frame) {
   // PingFrame has no contents to log, so just record that it was received.
   net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PING_FRAME_RECEIVED);
 }
 
 void QuicConnectionLogger::OnPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PUBLIC_RESET_PACKET_RECEIVED);
   UpdatePublicResetAddressMismatchHistogram(local_address_from_shlo_,
                                             packet.client_address);
 }
 
 void QuicConnectionLogger::OnVersionNegotiationPacket(
     const QuicVersionNegotiationPacket& packet) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_VERSION_NEGOTIATION_PACKET_RECEIVED,
-      base::Bind(&NetLogQuicVersionNegotiationPacketCallback, &packet));
+      base::Bind(NetLogQuicVersionNegotiationPacketCallback, &packet));
 }
 
 void QuicConnectionLogger::OnRevivedPacket(
     const QuicPacketHeader& revived_header,
     base::StringPiece payload) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_PACKET_HEADER_REVIVED,
-      base::Bind(&NetLogQuicPacketHeaderCallback, &revived_header));
+      base::Bind(NetLogQuicPacketHeaderCallback, &revived_header));
 }
 
 void QuicConnectionLogger::OnCryptoHandshakeMessageReceived(
     const CryptoHandshakeMessage& message) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_RECEIVED,
-      base::Bind(&NetLogQuicCryptoHandshakeMessageCallback, &message));
+      base::Bind(NetLogQuicCryptoHandshakeMessageCallback, &message));
 
   if (message.tag() == kSHLO) {
     StringPiece address;
     QuicSocketAddressCoder decoder;
     if (message.GetStringPiece(kCADR, &address) &&
         decoder.Decode(address.data(), address.size())) {
       local_address_from_shlo_ = IPEndPoint(decoder.ip(), decoder.port());
       UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.ConnectionTypeFromPeer",
                                 GetRealAddressFamily(
                                     local_address_from_shlo_.address()),
                                 ADDRESS_FAMILY_LAST);
     }
   }
 }
 
 void QuicConnectionLogger::OnCryptoHandshakeMessageSent(
     const CryptoHandshakeMessage& message) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_CRYPTO_HANDSHAKE_MESSAGE_SENT,
-      base::Bind(&NetLogQuicCryptoHandshakeMessageCallback, &message));
+      base::Bind(NetLogQuicCryptoHandshakeMessageCallback, &message));
 }
 
 void QuicConnectionLogger::OnConnectionClosed(QuicErrorCode error,
                                               bool from_peer) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_CLOSED,
-      base::Bind(&NetLogQuicOnConnectionClosedCallback, error, from_peer));
+      base::Bind(NetLogQuicOnConnectionClosedCallback, error, from_peer));
 }
 
 void QuicConnectionLogger::OnSuccessfulVersionNegotiation(
     const QuicVersion& version) {
   string quic_version = QuicVersionToString(version);
   net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_VERSION_NEGOTIATED,
                     NetLog::StringCallback("version", &quic_version));
 }
 
 void QuicConnectionLogger::UpdateReceivedFrameCounts(
     QuicStreamId stream_id,
     int num_frames_received,
     int num_duplicate_frames_received) {
   if (stream_id != kCryptoStreamId) {
     num_frames_received_ += num_frames_received;
     num_duplicate_frames_received_ += num_duplicate_frames_received;
   }
 }
 
 void QuicConnectionLogger::OnCertificateVerified(
     const CertVerifyResult& result) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_CERTIFICATE_VERIFIED,
-      base::Bind(&NetLogQuicCertificateVerifiedCallback, result.verified_cert));
+      base::Bind(NetLogQuicCertificateVerifiedCallback, result.verified_cert));
 }
 
 base::HistogramBase* QuicConnectionLogger::GetPacketSequenceNumberHistogram(
     const char* statistic_name) const {
   string prefix("Net.QuicSession.PacketReceived_");
   return base::LinearHistogram::FactoryGet(
       prefix + statistic_name + connection_description_,
       1, received_packets_.size(), received_packets_.size() + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 }
@@ skipping 144 matching lines @@
       continue;
     }
     // Record some overlapping patterns, to get a better picture, since this is
     // not very expensive.
     if (i % 3 == 0)
       six_packet_histogram->Add(recent_6_mask);
   }
 }
 
 }  // namespace net