Log QuicGoAwayFrames and QuicPingFrames, sent and received, in net log.

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 177 matching lines @@
 }
 
 base::Value* NetLogQuicBlockedFrameCallback(
     const QuicBlockedFrame* frame,
     NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("stream_id", frame->stream_id);
   return dict;
 }
 
+base::Value* NetLogQuicGoAwayFrameCallback(
+    const QuicGoAwayFrame* frame,
+    NetLog::LogLevel /* log_level */) {
+  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;
+}
+
 base::Value* NetLogQuicStopWaitingFrameCallback(
     const QuicStopWaitingFrame* frame,
     NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   base::DictionaryValue* sent_info = new base::DictionaryValue();
   dict->Set("sent_info", sent_info);
   sent_info->SetString("least_unacked",
                        base::Uint64ToString(frame->least_unacked));
   return dict;
 }
@@ skipping 171 matching lines @@
           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));
       break;
     case GOAWAY_FRAME:
+      net_log_.AddEvent(
+          NetLog::TYPE_QUIC_SESSION_GOAWAY_FRAME_SENT,
+          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));
       break;
     case BLOCKED_FRAME:
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_BLOCKED_FRAME_SENT,
           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));
       break;
+    case PING_FRAME:
+      // 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(
     QuicPacketSequenceNumber sequence_number,
     EncryptionLevel level,
     TransmissionType transmission_type,
     const QuicEncryptedPacket& packet,
@@ skipping 153 matching lines @@
       NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_RECEIVED,
       base::Bind(&NetLogQuicWindowUpdateFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnBlockedFrame(const QuicBlockedFrame& 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));
+}
+
+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(
@@ skipping 212 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