Add a DebugVisitor to QuicConnection to facilitate logging the activity on a QUIC connection.

net/quic/quic_connection.h

 // Copyright (c) 2012 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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 55 matching lines @@
 
   // Called when packets are acked by the peer.
   virtual void OnAck(AckedPackets acked_packets) = 0;
 
   // Called when a blocked socket becomes writable.  If all pending bytes for
   // this visitor are consumed by the connection successfully this should
   // return true, otherwise it should return false.
   virtual bool OnCanWrite() = 0;
 };
 
+// Interface which gets callbacks from the QuicConnection at interesting
+// points.  Implementations must not mutate the state of the connection
+// as a result of these callbacks.
+class QuicConnectionDebugVisitorInterface {
+ public:
+  virtual ~QuicConnectionDebugVisitorInterface() {}
+
+  // Called when a packet has been received, but before it is
+  // validated or parsed.
+  virtual void OnPacketReceived(const IPEndPoint& self_address,
+                                const IPEndPoint& peer_address,
+                                const QuicEncryptedPacket& packet) = 0;
+
+  // Called when the header of a packet has been parsed.
+  virtual void OnPacketHeader(const QuicPacketHeader& header) = 0;
+
+  // Called when a StreamFrame has been parsed.
+  virtual void OnStreamFrame(const QuicStreamFrame& frame) = 0;
+
+  // Called when a AckFrame has been parsed.
+  virtual void OnAckFrame(const QuicAckFrame& frame) = 0;
+
+  // Called when a CongestionFeedbackFrame has been parsed.
+  virtual void OnCongestionFeedbackFrame(
+      const QuicCongestionFeedbackFrame& frame) = 0;
+
+  // Called when a RstStreamFrame has been parsed.
+  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) = 0;
+
+  // Called when a ConnectionCloseFrame has been parsed.
+  virtual void OnConnectionCloseFrame(
+      const QuicConnectionCloseFrame& frame) = 0;
+
+  // Called when a public reset packet has been received.
+  virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) = 0;
+
+  // Called after a packet has been successfully parsed which results
+  // in the revival of a packet via FEC.
+  virtual void OnRevivedPacket(const QuicPacketHeader& revived_header,
+                               base::StringPiece payload) = 0;
+};
+
 class NET_EXPORT_PRIVATE QuicConnectionHelperInterface {
  public:
   virtual ~QuicConnectionHelperInterface() {}
 
   // Sets the QuicConnection to be used by this helper.  This method
   // must only be called once.
   virtual void SetConnection(QuicConnection* connection) = 0;
 
   // Returns a QuicClock to be used for all time related functions.
   virtual const QuicClock* GetClock() const = 0;
@@ skipping 102 matching lines @@
   virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
   virtual void OnConnectionCloseFrame(
       const QuicConnectionCloseFrame& frame) OVERRIDE;
   virtual void OnFecData(const QuicFecData& fec) OVERRIDE;
   virtual void OnPacketComplete() OVERRIDE;
 
   // Accessors
   void set_visitor(QuicConnectionVisitorInterface* visitor) {
     visitor_ = visitor;
   }
+  void set_debug_visitor(QuicConnectionDebugVisitorInterface* debug_visitor) {
+    debug_visitor_ = debug_visitor;
+  }
   const IPEndPoint& self_address() const { return self_address_; }
   const IPEndPoint& peer_address() const { return peer_address_; }
   QuicGuid guid() const { return guid_; }
   const QuicClock* clock() const { return clock_; }
   QuicRandom* random_generator() const { return random_generator_; }
 
   // Updates the internal state concerning which packets have been acked.
   void RecordPacketReceived(const QuicPacketHeader& header);
 
   // Called by a RetransmissionAlarm when the timer goes off.  If the peer
@@ skipping 225 matching lines @@
 
   // Pending control frames, besides the ack and congestion control frames.
   QuicFrames queued_control_frames_;
 
   // True when the socket becomes unwritable.
   bool write_blocked_;
 
   FecGroupMap group_map_;
 
   QuicConnectionVisitorInterface* visitor_;
+  QuicConnectionDebugVisitorInterface* debug_visitor_;
   QuicPacketCreator packet_creator_;
 
   // Network idle time before we kill of this connection.
   const QuicTime::Delta timeout_;
   // The time that we got or tried to send a packet for this connection.
   QuicTime time_of_last_packet_;
 
   // Congestion manager which controls the rate the connection sends packets
   // as well as collecting and generating congestion feedback.
   QuicCongestionManager congestion_manager_;
 
   // True by default.  False if we've received or sent an explicit connection
   // close.
   bool connected_;
 
   // True if the last ack received from the peer may have been truncated.  False
   // otherwise.
   bool received_truncated_ack_;
 
   bool send_ack_in_response_to_packet_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_