Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(227)

Side by Side Diff: net/quic/quic_connection_logger.cc

Issue 1059843002: Refactor NetLog::LogLevel --> NetLogCaptureMode. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: rebase again to fix a merge conflict Created 5 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « net/quic/quic_client_session.cc ('k') | net/quic/quic_http_utils.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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 20 matching lines...) Expand all
31 namespace { 31 namespace {
32 32
33 // We have ranges-of-buckets in the cumulative histogram (covering 21 packet 33 // We have ranges-of-buckets in the cumulative histogram (covering 21 packet
34 // sequences) of length 2, 3, 4, ... 22. 34 // sequences) of length 2, 3, 4, ... 22.
35 // Hence the largest sample is bounded by the sum of those numbers. 35 // Hence the largest sample is bounded by the sum of those numbers.
36 const int kBoundingSampleInCumulativeHistogram = ((2 + 22) * 21) / 2; 36 const int kBoundingSampleInCumulativeHistogram = ((2 + 22) * 21) / 2;
37 37
38 base::Value* NetLogQuicPacketCallback(const IPEndPoint* self_address, 38 base::Value* NetLogQuicPacketCallback(const IPEndPoint* self_address,
39 const IPEndPoint* peer_address, 39 const IPEndPoint* peer_address,
40 size_t packet_size, 40 size_t packet_size,
41 NetLog::LogLevel /* log_level */) { 41 NetLogCaptureMode /* capture_mode */) {
42 base::DictionaryValue* dict = new base::DictionaryValue(); 42 base::DictionaryValue* dict = new base::DictionaryValue();
43 dict->SetString("self_address", self_address->ToString()); 43 dict->SetString("self_address", self_address->ToString());
44 dict->SetString("peer_address", peer_address->ToString()); 44 dict->SetString("peer_address", peer_address->ToString());
45 dict->SetInteger("size", packet_size); 45 dict->SetInteger("size", packet_size);
46 return dict; 46 return dict;
47 } 47 }
48 48
49 base::Value* NetLogQuicPacketSentCallback( 49 base::Value* NetLogQuicPacketSentCallback(
50 const SerializedPacket& serialized_packet, 50 const SerializedPacket& serialized_packet,
51 EncryptionLevel level, 51 EncryptionLevel level,
52 TransmissionType transmission_type, 52 TransmissionType transmission_type,
53 size_t packet_size, 53 size_t packet_size,
54 QuicTime sent_time, 54 QuicTime sent_time,
55 NetLog::LogLevel /* log_level */) { 55 NetLogCaptureMode /* capture_mode */) {
56 base::DictionaryValue* dict = new base::DictionaryValue(); 56 base::DictionaryValue* dict = new base::DictionaryValue();
57 dict->SetInteger("encryption_level", level); 57 dict->SetInteger("encryption_level", level);
58 dict->SetInteger("transmission_type", transmission_type); 58 dict->SetInteger("transmission_type", transmission_type);
59 dict->SetString("packet_sequence_number", 59 dict->SetString("packet_sequence_number",
60 base::Uint64ToString(serialized_packet.sequence_number)); 60 base::Uint64ToString(serialized_packet.sequence_number));
61 dict->SetInteger("size", packet_size); 61 dict->SetInteger("size", packet_size);
62 dict->SetInteger("sent_time_us", 62 dict->SetInteger("sent_time_us",
63 static_cast<int>(sent_time.ToDebuggingValue())); 63 static_cast<int>(sent_time.ToDebuggingValue()));
64 return dict; 64 return dict;
65 } 65 }
66 66
67 base::Value* NetLogQuicPacketRetransmittedCallback( 67 base::Value* NetLogQuicPacketRetransmittedCallback(
68 QuicPacketSequenceNumber old_sequence_number, 68 QuicPacketSequenceNumber old_sequence_number,
69 QuicPacketSequenceNumber new_sequence_number, 69 QuicPacketSequenceNumber new_sequence_number,
70 NetLog::LogLevel /* log_level */) { 70 NetLogCaptureMode /* capture_mode */) {
71 base::DictionaryValue* dict = new base::DictionaryValue(); 71 base::DictionaryValue* dict = new base::DictionaryValue();
72 dict->SetString("old_packet_sequence_number", 72 dict->SetString("old_packet_sequence_number",
73 base::Uint64ToString(old_sequence_number)); 73 base::Uint64ToString(old_sequence_number));
74 dict->SetString("new_packet_sequence_number", 74 dict->SetString("new_packet_sequence_number",
75 base::Uint64ToString(new_sequence_number)); 75 base::Uint64ToString(new_sequence_number));
76 return dict; 76 return dict;
77 } 77 }
78 78
79 base::Value* NetLogQuicPacketHeaderCallback(const QuicPacketHeader* header, 79 base::Value* NetLogQuicPacketHeaderCallback(
80 NetLog::LogLevel /* log_level */) { 80 const QuicPacketHeader* header,
81 NetLogCaptureMode /* capture_mode */) {
81 base::DictionaryValue* dict = new base::DictionaryValue(); 82 base::DictionaryValue* dict = new base::DictionaryValue();
82 dict->SetString("connection_id", 83 dict->SetString("connection_id",
83 base::Uint64ToString(header->public_header.connection_id)); 84 base::Uint64ToString(header->public_header.connection_id));
84 dict->SetInteger("reset_flag", header->public_header.reset_flag); 85 dict->SetInteger("reset_flag", header->public_header.reset_flag);
85 dict->SetInteger("version_flag", header->public_header.version_flag); 86 dict->SetInteger("version_flag", header->public_header.version_flag);
86 dict->SetString("packet_sequence_number", 87 dict->SetString("packet_sequence_number",
87 base::Uint64ToString(header->packet_sequence_number)); 88 base::Uint64ToString(header->packet_sequence_number));
88 dict->SetInteger("entropy_flag", header->entropy_flag); 89 dict->SetInteger("entropy_flag", header->entropy_flag);
89 dict->SetInteger("fec_flag", header->fec_flag); 90 dict->SetInteger("fec_flag", header->fec_flag);
90 dict->SetInteger("fec_group", static_cast<int>(header->fec_group)); 91 dict->SetInteger("fec_group", static_cast<int>(header->fec_group));
91 return dict; 92 return dict;
92 } 93 }
93 94
94 base::Value* NetLogQuicStreamFrameCallback(const QuicStreamFrame* frame, 95 base::Value* NetLogQuicStreamFrameCallback(
95 NetLog::LogLevel /* log_level */) { 96 const QuicStreamFrame* frame,
97 NetLogCaptureMode /* capture_mode */) {
96 base::DictionaryValue* dict = new base::DictionaryValue(); 98 base::DictionaryValue* dict = new base::DictionaryValue();
97 dict->SetInteger("stream_id", frame->stream_id); 99 dict->SetInteger("stream_id", frame->stream_id);
98 dict->SetBoolean("fin", frame->fin); 100 dict->SetBoolean("fin", frame->fin);
99 dict->SetString("offset", base::Uint64ToString(frame->offset)); 101 dict->SetString("offset", base::Uint64ToString(frame->offset));
100 dict->SetInteger("length", frame->data.TotalBufferSize()); 102 dict->SetInteger("length", frame->data.TotalBufferSize());
101 return dict; 103 return dict;
102 } 104 }
103 105
104 base::Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame, 106 base::Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame,
105 NetLog::LogLevel /* log_level */) { 107 NetLogCaptureMode /* capture_mode */) {
106 base::DictionaryValue* dict = new base::DictionaryValue(); 108 base::DictionaryValue* dict = new base::DictionaryValue();
107 dict->SetString("largest_observed", 109 dict->SetString("largest_observed",
108 base::Uint64ToString(frame->largest_observed)); 110 base::Uint64ToString(frame->largest_observed));
109 dict->SetInteger( 111 dict->SetInteger(
110 "delta_time_largest_observed_us", 112 "delta_time_largest_observed_us",
111 static_cast<int>(frame->delta_time_largest_observed.ToMicroseconds())); 113 static_cast<int>(frame->delta_time_largest_observed.ToMicroseconds()));
112 dict->SetInteger("entropy_hash", 114 dict->SetInteger("entropy_hash",
113 frame->entropy_hash); 115 frame->entropy_hash);
114 dict->SetBoolean("truncated", frame->is_truncated); 116 dict->SetBoolean("truncated", frame->is_truncated);
115 117
(...skipping 23 matching lines...) Expand all
139 info->SetInteger("received", 141 info->SetInteger("received",
140 static_cast<int>(it->second.ToDebuggingValue())); 142 static_cast<int>(it->second.ToDebuggingValue()));
141 received->Append(info); 143 received->Append(info);
142 } 144 }
143 145
144 return dict; 146 return dict;
145 } 147 }
146 148
147 base::Value* NetLogQuicRstStreamFrameCallback( 149 base::Value* NetLogQuicRstStreamFrameCallback(
148 const QuicRstStreamFrame* frame, 150 const QuicRstStreamFrame* frame,
149 NetLog::LogLevel /* log_level */) { 151 NetLogCaptureMode /* capture_mode */) {
150 base::DictionaryValue* dict = new base::DictionaryValue(); 152 base::DictionaryValue* dict = new base::DictionaryValue();
151 dict->SetInteger("stream_id", frame->stream_id); 153 dict->SetInteger("stream_id", frame->stream_id);
152 dict->SetInteger("quic_rst_stream_error", frame->error_code); 154 dict->SetInteger("quic_rst_stream_error", frame->error_code);
153 dict->SetString("details", frame->error_details); 155 dict->SetString("details", frame->error_details);
154 return dict; 156 return dict;
155 } 157 }
156 158
157 base::Value* NetLogQuicConnectionCloseFrameCallback( 159 base::Value* NetLogQuicConnectionCloseFrameCallback(
158 const QuicConnectionCloseFrame* frame, 160 const QuicConnectionCloseFrame* frame,
159 NetLog::LogLevel /* log_level */) { 161 NetLogCaptureMode /* capture_mode */) {
160 base::DictionaryValue* dict = new base::DictionaryValue(); 162 base::DictionaryValue* dict = new base::DictionaryValue();
161 dict->SetInteger("quic_error", frame->error_code); 163 dict->SetInteger("quic_error", frame->error_code);
162 dict->SetString("details", frame->error_details); 164 dict->SetString("details", frame->error_details);
163 return dict; 165 return dict;
164 } 166 }
165 167
166 base::Value* NetLogQuicWindowUpdateFrameCallback( 168 base::Value* NetLogQuicWindowUpdateFrameCallback(
167 const QuicWindowUpdateFrame* frame, 169 const QuicWindowUpdateFrame* frame,
168 NetLog::LogLevel /* log_level */) { 170 NetLogCaptureMode /* capture_mode */) {
169 base::DictionaryValue* dict = new base::DictionaryValue(); 171 base::DictionaryValue* dict = new base::DictionaryValue();
170 dict->SetInteger("stream_id", frame->stream_id); 172 dict->SetInteger("stream_id", frame->stream_id);
171 dict->SetString("byte_offset", base::Uint64ToString(frame->byte_offset)); 173 dict->SetString("byte_offset", base::Uint64ToString(frame->byte_offset));
172 return dict; 174 return dict;
173 } 175 }
174 176
175 base::Value* NetLogQuicBlockedFrameCallback( 177 base::Value* NetLogQuicBlockedFrameCallback(
176 const QuicBlockedFrame* frame, 178 const QuicBlockedFrame* frame,
177 NetLog::LogLevel /* log_level */) { 179 NetLogCaptureMode /* capture_mode */) {
178 base::DictionaryValue* dict = new base::DictionaryValue(); 180 base::DictionaryValue* dict = new base::DictionaryValue();
179 dict->SetInteger("stream_id", frame->stream_id); 181 dict->SetInteger("stream_id", frame->stream_id);
180 return dict; 182 return dict;
181 } 183 }
182 184
183 base::Value* NetLogQuicGoAwayFrameCallback( 185 base::Value* NetLogQuicGoAwayFrameCallback(
184 const QuicGoAwayFrame* frame, 186 const QuicGoAwayFrame* frame,
185 NetLog::LogLevel /* log_level */) { 187 NetLogCaptureMode /* capture_mode */) {
186 base::DictionaryValue* dict = new base::DictionaryValue(); 188 base::DictionaryValue* dict = new base::DictionaryValue();
187 dict->SetInteger("quic_error", frame->error_code); 189 dict->SetInteger("quic_error", frame->error_code);
188 dict->SetInteger("last_good_stream_id", frame->last_good_stream_id); 190 dict->SetInteger("last_good_stream_id", frame->last_good_stream_id);
189 dict->SetString("reason_phrase", frame->reason_phrase); 191 dict->SetString("reason_phrase", frame->reason_phrase);
190 return dict; 192 return dict;
191 } 193 }
192 194
193 base::Value* NetLogQuicStopWaitingFrameCallback( 195 base::Value* NetLogQuicStopWaitingFrameCallback(
194 const QuicStopWaitingFrame* frame, 196 const QuicStopWaitingFrame* frame,
195 NetLog::LogLevel /* log_level */) { 197 NetLogCaptureMode /* capture_mode */) {
196 base::DictionaryValue* dict = new base::DictionaryValue(); 198 base::DictionaryValue* dict = new base::DictionaryValue();
197 base::DictionaryValue* sent_info = new base::DictionaryValue(); 199 base::DictionaryValue* sent_info = new base::DictionaryValue();
198 dict->Set("sent_info", sent_info); 200 dict->Set("sent_info", sent_info);
199 sent_info->SetString("least_unacked", 201 sent_info->SetString("least_unacked",
200 base::Uint64ToString(frame->least_unacked)); 202 base::Uint64ToString(frame->least_unacked));
201 return dict; 203 return dict;
202 } 204 }
203 205
204 base::Value* NetLogQuicVersionNegotiationPacketCallback( 206 base::Value* NetLogQuicVersionNegotiationPacketCallback(
205 const QuicVersionNegotiationPacket* packet, 207 const QuicVersionNegotiationPacket* packet,
206 NetLog::LogLevel /* log_level */) { 208 NetLogCaptureMode /* capture_mode */) {
207 base::DictionaryValue* dict = new base::DictionaryValue(); 209 base::DictionaryValue* dict = new base::DictionaryValue();
208 base::ListValue* versions = new base::ListValue(); 210 base::ListValue* versions = new base::ListValue();
209 dict->Set("versions", versions); 211 dict->Set("versions", versions);
210 for (QuicVersionVector::const_iterator it = packet->versions.begin(); 212 for (QuicVersionVector::const_iterator it = packet->versions.begin();
211 it != packet->versions.end(); ++it) { 213 it != packet->versions.end(); ++it) {
212 versions->AppendString(QuicVersionToString(*it)); 214 versions->AppendString(QuicVersionToString(*it));
213 } 215 }
214 return dict; 216 return dict;
215 } 217 }
216 218
217 base::Value* NetLogQuicCryptoHandshakeMessageCallback( 219 base::Value* NetLogQuicCryptoHandshakeMessageCallback(
218 const CryptoHandshakeMessage* message, 220 const CryptoHandshakeMessage* message,
219 NetLog::LogLevel /* log_level */) { 221 NetLogCaptureMode /* capture_mode */) {
220 base::DictionaryValue* dict = new base::DictionaryValue(); 222 base::DictionaryValue* dict = new base::DictionaryValue();
221 dict->SetString("quic_crypto_handshake_message", message->DebugString()); 223 dict->SetString("quic_crypto_handshake_message", message->DebugString());
222 return dict; 224 return dict;
223 } 225 }
224 226
225 base::Value* NetLogQuicOnConnectionClosedCallback( 227 base::Value* NetLogQuicOnConnectionClosedCallback(
226 QuicErrorCode error, 228 QuicErrorCode error,
227 bool from_peer, 229 bool from_peer,
228 NetLog::LogLevel /* log_level */) { 230 NetLogCaptureMode /* capture_mode */) {
229 base::DictionaryValue* dict = new base::DictionaryValue(); 231 base::DictionaryValue* dict = new base::DictionaryValue();
230 dict->SetInteger("quic_error", error); 232 dict->SetInteger("quic_error", error);
231 dict->SetBoolean("from_peer", from_peer); 233 dict->SetBoolean("from_peer", from_peer);
232 return dict; 234 return dict;
233 } 235 }
234 236
235 base::Value* NetLogQuicCertificateVerifiedCallback( 237 base::Value* NetLogQuicCertificateVerifiedCallback(
236 scoped_refptr<X509Certificate> cert, 238 scoped_refptr<X509Certificate> cert,
237 NetLog::LogLevel /* log_level */) { 239 NetLogCaptureMode /* capture_mode */) {
238 // Only the subjects are logged so that we can investigate connection pooling. 240 // Only the subjects are logged so that we can investigate connection pooling.
239 // More fields could be logged in the future. 241 // More fields could be logged in the future.
240 std::vector<std::string> dns_names; 242 std::vector<std::string> dns_names;
241 cert->GetDNSNames(&dns_names); 243 cert->GetDNSNames(&dns_names);
242 base::DictionaryValue* dict = new base::DictionaryValue(); 244 base::DictionaryValue* dict = new base::DictionaryValue();
243 base::ListValue* subjects = new base::ListValue(); 245 base::ListValue* subjects = new base::ListValue();
244 for (std::vector<std::string>::const_iterator it = dns_names.begin(); 246 for (std::vector<std::string>::const_iterator it = dns_names.begin();
245 it != dns_names.end(); it++) { 247 it != dns_names.end(); it++) {
246 subjects->Append(new base::StringValue(*it)); 248 subjects->Append(new base::StringValue(*it));
247 } 249 }
(...skipping 613 matching lines...) Expand 10 before | Expand all | Expand 10 after
861 continue; 863 continue;
862 } 864 }
863 // Record some overlapping patterns, to get a better picture, since this is 865 // Record some overlapping patterns, to get a better picture, since this is
864 // not very expensive. 866 // not very expensive.
865 if (i % 3 == 0) 867 if (i % 3 == 0)
866 six_packet_histogram->Add(recent_6_mask); 868 six_packet_histogram->Add(recent_6_mask);
867 } 869 }
868 } 870 }
869 871
870 } // namespace net 872 } // namespace net
OLDNEW
« no previous file with comments | « net/quic/quic_client_session.cc ('k') | net/quic/quic_http_utils.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698