Index: net/quic/quic_connection_logger.cc |
diff --git a/net/quic/quic_connection_logger.cc b/net/quic/quic_connection_logger.cc |
index fd60d8e8d526787186326f4cc69699b1f6e0ecc1..b903c6266161dd164917dde8cbd9e06e509a5dbd 100644 |
--- a/net/quic/quic_connection_logger.cc |
+++ b/net/quic/quic_connection_logger.cc |
@@ -35,25 +35,26 @@ namespace { |
// 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", |
@@ -61,25 +62,25 @@ base::Value* NetLogQuicPacketSentCallback( |
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); |
@@ -89,23 +90,24 @@ base::Value* NetLogQuicPacketHeaderCallback( |
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( |
@@ -115,140 +117,140 @@ base::Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame, |
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) { |
@@ -351,12 +353,12 @@ void QuicConnectionLogger::OnFrameAddedToPacket(const QuicFrame& frame) { |
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(); |
@@ -384,39 +386,33 @@ void QuicConnectionLogger::OnFrameAddedToPacket(const QuicFrame& frame) { |
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", |
@@ -441,14 +437,13 @@ void QuicConnectionLogger::OnPacketSent( |
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)); |
} |
} |
@@ -464,10 +459,9 @@ void QuicConnectionLogger::OnPacketReceived(const IPEndPoint& self_address, |
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( |
@@ -490,9 +484,8 @@ void QuicConnectionLogger::OnProtocolVersionMismatch( |
} |
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) { |
@@ -525,15 +518,13 @@ void QuicConnectionLogger::OnPacketHeader(const QuicPacketHeader& header) { |
} |
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() && |
@@ -583,44 +574,38 @@ void QuicConnectionLogger::OnAckFrame(const QuicAckFrame& frame) { |
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) { |
@@ -639,7 +624,7 @@ 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( |
@@ -647,14 +632,14 @@ void QuicConnectionLogger::OnRevivedPacket( |
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; |
@@ -674,14 +659,14 @@ 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( |
@@ -705,7 +690,7 @@ 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( |