OLD | NEW |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/quic_connection_logger.h" | 5 #include "net/quic/quic_connection_logger.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <string> | 8 #include <string> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
97 dict->SetInteger("stream_id", frame->stream_id); | 97 dict->SetInteger("stream_id", frame->stream_id); |
98 dict->SetBoolean("fin", frame->fin); | 98 dict->SetBoolean("fin", frame->fin); |
99 dict->SetString("offset", base::Uint64ToString(frame->offset)); | 99 dict->SetString("offset", base::Uint64ToString(frame->offset)); |
100 dict->SetInteger("length", frame->data.TotalBufferSize()); | 100 dict->SetInteger("length", frame->data.TotalBufferSize()); |
101 return dict; | 101 return dict; |
102 } | 102 } |
103 | 103 |
104 base::Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame, | 104 base::Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame, |
105 NetLog::LogLevel /* log_level */) { | 105 NetLog::LogLevel /* log_level */) { |
106 base::DictionaryValue* dict = new base::DictionaryValue(); | 106 base::DictionaryValue* dict = new base::DictionaryValue(); |
107 base::DictionaryValue* received_info = new base::DictionaryValue(); | 107 dict->SetString("largest_observed", |
108 dict->Set("received_info", received_info); | 108 base::Uint64ToString(frame->largest_observed)); |
109 received_info->SetString( | 109 dict->SetBoolean("truncated", frame->is_truncated); |
110 "largest_observed", | |
111 base::Uint64ToString(frame->received_info.largest_observed)); | |
112 received_info->SetBoolean("truncated", frame->received_info.is_truncated); | |
113 base::ListValue* missing = new base::ListValue(); | 110 base::ListValue* missing = new base::ListValue(); |
114 received_info->Set("missing_packets", missing); | 111 dict->Set("missing_packets", missing); |
115 const SequenceNumberSet& missing_packets = | 112 const SequenceNumberSet& missing_packets = frame->missing_packets; |
116 frame->received_info.missing_packets; | |
117 for (SequenceNumberSet::const_iterator it = missing_packets.begin(); | 113 for (SequenceNumberSet::const_iterator it = missing_packets.begin(); |
118 it != missing_packets.end(); ++it) { | 114 it != missing_packets.end(); ++it) { |
119 missing->AppendString(base::Uint64ToString(*it)); | 115 missing->AppendString(base::Uint64ToString(*it)); |
120 } | 116 } |
121 return dict; | 117 return dict; |
122 } | 118 } |
123 | 119 |
124 base::Value* NetLogQuicCongestionFeedbackFrameCallback( | 120 base::Value* NetLogQuicCongestionFeedbackFrameCallback( |
125 const QuicCongestionFeedbackFrame* frame, | 121 const QuicCongestionFeedbackFrame* frame, |
126 NetLog::LogLevel /* log_level */) { | 122 NetLog::LogLevel /* log_level */) { |
127 base::DictionaryValue* dict = new base::DictionaryValue(); | 123 base::DictionaryValue* dict = new base::DictionaryValue(); |
128 switch (frame->type) { | 124 switch (frame->type) { |
129 case kInterArrival: { | 125 case kInterArrival: { |
130 dict->SetString("type", "InterArrival"); | 126 dict->SetString("type", "InterArrival"); |
131 base::ListValue* received = new base::ListValue(); | 127 base::ListValue* received = new base::ListValue(); |
132 dict->Set("received_packets", received); | 128 dict->Set("received_packets", received); |
133 for (TimeMap::const_iterator it = | 129 for (TimeMap::const_iterator it = |
134 frame->inter_arrival.received_packet_times.begin(); | 130 frame->inter_arrival.received_packet_times.begin(); |
135 it != frame->inter_arrival.received_packet_times.end(); ++it) { | 131 it != frame->inter_arrival.received_packet_times.end(); ++it) { |
136 string value = base::Uint64ToString(it->first) + "@" + | 132 string value = base::Uint64ToString(it->first) + "@" + |
137 base::Uint64ToString(it->second.ToDebuggingValue()); | 133 base::Uint64ToString(it->second.ToDebuggingValue()); |
138 received->AppendString(value); | 134 received->AppendString(value); |
139 } | 135 } |
140 break; | 136 break; |
141 } | 137 } |
142 case kFixRate: | |
143 dict->SetString("type", "FixRate"); | |
144 dict->SetInteger("bitrate_in_bytes_per_second", | |
145 frame->fix_rate.bitrate.ToBytesPerSecond()); | |
146 break; | |
147 case kTCP: | 138 case kTCP: |
148 dict->SetString("type", "TCP"); | 139 dict->SetString("type", "TCP"); |
149 dict->SetInteger("receive_window", frame->tcp.receive_window); | 140 dict->SetInteger("receive_window", frame->tcp.receive_window); |
150 break; | 141 break; |
151 } | 142 } |
152 | 143 |
153 return dict; | 144 return dict; |
154 } | 145 } |
155 | 146 |
156 base::Value* NetLogQuicRstStreamFrameCallback( | 147 base::Value* NetLogQuicRstStreamFrameCallback( |
(...skipping 219 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
376 break; | 367 break; |
377 case STREAM_FRAME: | 368 case STREAM_FRAME: |
378 net_log_.AddEvent( | 369 net_log_.AddEvent( |
379 NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_SENT, | 370 NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_SENT, |
380 base::Bind(&NetLogQuicStreamFrameCallback, frame.stream_frame)); | 371 base::Bind(&NetLogQuicStreamFrameCallback, frame.stream_frame)); |
381 break; | 372 break; |
382 case ACK_FRAME: | 373 case ACK_FRAME: |
383 net_log_.AddEvent( | 374 net_log_.AddEvent( |
384 NetLog::TYPE_QUIC_SESSION_ACK_FRAME_SENT, | 375 NetLog::TYPE_QUIC_SESSION_ACK_FRAME_SENT, |
385 base::Bind(&NetLogQuicAckFrameCallback, frame.ack_frame)); | 376 base::Bind(&NetLogQuicAckFrameCallback, frame.ack_frame)); |
386 if (frame.ack_frame->received_info.is_truncated) | 377 if (frame.ack_frame->is_truncated) |
387 ++num_truncated_acks_sent_; | 378 ++num_truncated_acks_sent_; |
388 break; | 379 break; |
389 case CONGESTION_FEEDBACK_FRAME: | 380 case CONGESTION_FEEDBACK_FRAME: |
390 net_log_.AddEvent( | 381 net_log_.AddEvent( |
391 NetLog::TYPE_QUIC_SESSION_CONGESTION_FEEDBACK_FRAME_SENT, | 382 NetLog::TYPE_QUIC_SESSION_CONGESTION_FEEDBACK_FRAME_SENT, |
392 base::Bind(&NetLogQuicCongestionFeedbackFrameCallback, | 383 base::Bind(&NetLogQuicCongestionFeedbackFrameCallback, |
393 frame.congestion_feedback_frame)); | 384 frame.congestion_feedback_frame)); |
394 break; | 385 break; |
395 case RST_STREAM_FRAME: | 386 case RST_STREAM_FRAME: |
396 UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeClient", | 387 UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeClient", |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
519 void QuicConnectionLogger::OnAckFrame(const QuicAckFrame& frame) { | 510 void QuicConnectionLogger::OnAckFrame(const QuicAckFrame& frame) { |
520 net_log_.AddEvent( | 511 net_log_.AddEvent( |
521 NetLog::TYPE_QUIC_SESSION_ACK_FRAME_RECEIVED, | 512 NetLog::TYPE_QUIC_SESSION_ACK_FRAME_RECEIVED, |
522 base::Bind(&NetLogQuicAckFrameCallback, &frame)); | 513 base::Bind(&NetLogQuicAckFrameCallback, &frame)); |
523 | 514 |
524 const size_t kApproximateLargestSoloAckBytes = 100; | 515 const size_t kApproximateLargestSoloAckBytes = 100; |
525 if (last_received_packet_sequence_number_ < received_acks_.size() && | 516 if (last_received_packet_sequence_number_ < received_acks_.size() && |
526 last_received_packet_size_ < kApproximateLargestSoloAckBytes) | 517 last_received_packet_size_ < kApproximateLargestSoloAckBytes) |
527 received_acks_[last_received_packet_sequence_number_] = true; | 518 received_acks_[last_received_packet_sequence_number_] = true; |
528 | 519 |
529 if (frame.received_info.is_truncated) | 520 if (frame.is_truncated) |
530 ++num_truncated_acks_received_; | 521 ++num_truncated_acks_received_; |
531 | 522 |
532 if (frame.received_info.missing_packets.empty()) | 523 if (frame.missing_packets.empty()) |
533 return; | 524 return; |
534 | 525 |
535 SequenceNumberSet missing_packets = frame.received_info.missing_packets; | 526 SequenceNumberSet missing_packets = frame.missing_packets; |
536 SequenceNumberSet::const_iterator it = missing_packets.lower_bound( | 527 SequenceNumberSet::const_iterator it = missing_packets.lower_bound( |
537 largest_received_missing_packet_sequence_number_); | 528 largest_received_missing_packet_sequence_number_); |
538 if (it == missing_packets.end()) | 529 if (it == missing_packets.end()) |
539 return; | 530 return; |
540 | 531 |
541 if (*it == largest_received_missing_packet_sequence_number_) { | 532 if (*it == largest_received_missing_packet_sequence_number_) { |
542 ++it; | 533 ++it; |
543 if (it == missing_packets.end()) | 534 if (it == missing_packets.end()) |
544 return; | 535 return; |
545 } | 536 } |
(...skipping 304 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
850 continue; | 841 continue; |
851 } | 842 } |
852 // Record some overlapping patterns, to get a better picture, since this is | 843 // Record some overlapping patterns, to get a better picture, since this is |
853 // not very expensive. | 844 // not very expensive. |
854 if (i % 3 == 0) | 845 if (i % 3 == 0) |
855 six_packet_histogram->Add(recent_6_mask); | 846 six_packet_histogram->Add(recent_6_mask); |
856 } | 847 } |
857 } | 848 } |
858 | 849 |
859 } // namespace net | 850 } // namespace net |
OLD | NEW |